@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

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

@@ -31,93 +31,25 @@ __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_integrity_plugin_js_namespaceObject = require("./integrity-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);
+    return new runtime_namespaceObject.ModuleFederation({
+        name: options.hostName,
+        remotes: remotes.map(({ name, entry, type })=>({
+                name,
+                entry,
+                ...type ? {
+                    type
+                } : {}
+            })),
+        shared: options.shared ?? {},
+        plugins: [
+            ...options.plugins ?? [],
+            (0, external_integrity_plugin_js_namespaceObject.createBackendFederationIntegrityPlugin)(options, remotes)
+        ]
+    });
 }
 exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

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

@@ -39,10 +39,8 @@ function validateLoadedBackendFederatedEffectApi(loaded, options) {
     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
-        });
+    {
+        const issues = (0, external_identity_js_namespaceObject.validateExpectedBackendFederationIdentity)(loaded, options.expected);
         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;

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

@@ -33,9 +33,11 @@ __webpack_require__.d(__webpack_exports__, {
 const index_js_namespaceObject = require("../backend-federation/index.js");
 const load_js_namespaceObject = require("../backend-federation/load.js");
 const external_errors_js_namespaceObject = require("./errors.js");
+const external_metadata_js_namespaceObject = require("./metadata.js");
 const external_reference_js_namespaceObject = require("./reference.js");
 const external_remote_js_namespaceObject = require("./remote.js");
 const external_validation_js_namespaceObject = require("./validation.js");
+const DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS = 10000;
 function createManifestLoadScope(options) {
     const controller = new AbortController();
     const policyTimeouts = [
@@ -47,7 +49,8 @@ function createManifestLoadScope(options) {
         ...policyTimeouts
     ].filter((timeout)=>void 0 !== timeout);
     for (const timeout of configuredTimeouts)if (!Number.isSafeInteger(timeout) || timeout < 0) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', '[BFF][Effect] Backend federation timeoutMs must be a non-negative safe integer.');
-    const timeoutMs = options.timeoutMs ?? (policyTimeouts.length > 0 ? Math.min(...policyTimeouts) : 0);
+    const positivePolicyTimeouts = policyTimeouts.filter((timeout)=>timeout > 0);
+    const timeoutMs = options.timeoutMs ?? (0 === policyTimeouts.length ? DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS : positivePolicyTimeouts.length > 0 ? Math.min(...positivePolicyTimeouts) : 0);
     const inputSignals = [
         options.signal,
         options.manifestPolicy?.signal,
@@ -101,6 +104,27 @@ function isCallerPinnedStaticRemote(options, remote) {
 function throwIfManifestLoadAborted(signal) {
     if (signal.aborted) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('remote_unavailable', '[BFF][Effect] Backend federation load was aborted before remote execution.', signal.reason);
 }
+function settleOnSharedAbort(promise, signal) {
+    if (signal.aborted) {
+        promise.catch(()=>{});
+        throwIfManifestLoadAborted(signal);
+    }
+    let onAbort;
+    const aborted = new Promise((_resolve, reject)=>{
+        onAbort = ()=>{
+            reject(new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('remote_unavailable', '[BFF][Effect] Backend federation load was aborted before remote execution.', signal.reason));
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+    });
+    return Promise.race([
+        promise,
+        aborted
+    ]).finally(()=>{
+        if (onAbort) signal.removeEventListener('abort', onAbort);
+    });
+}
 async function loadBackendFederatedEffectApiFromManifest(options) {
     let manifest;
     let remote;
@@ -108,7 +132,7 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
     try {
         scope = createManifestLoadScope(options);
         throwIfManifestLoadAborted(scope.signal);
-        manifest = await (0, external_reference_js_namespaceObject.loadBackendFederationManifest)({
+        manifest = await settleOnSharedAbort((0, external_reference_js_namespaceObject.loadBackendFederationManifest)({
             ...options,
             manifestPolicy: {
                 ...options.manifestPolicy,
@@ -117,7 +141,7 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
             },
             signal: scope.signal,
             timeoutMs: 0
-        });
+        }), scope.signal);
         (0, external_validation_js_namespaceObject.validateBackendFederationManifest)(manifest, options.expected);
         remote = (0, external_remote_js_namespaceObject.resolveBackendFederationRemoteFromManifest)(manifest, options.remote);
         throwIfManifestLoadAborted(scope.signal);
@@ -127,12 +151,19 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
         if (remoteManifest && /^https?:\/\//iu.test(remote.entry) && !hasPinnedRemoteEntryExpectation(options)) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} from a network manifest requires caller-pinned entryUrl, remoteName, sha256, and byteLength values.`);
         if (/^https?:\/\//iu.test(remote.entry) && void 0 === remote.verification && options.entryPolicy?.expected === void 0) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} requires entry.sha256 and entry.byteLength before network execution.`);
         if (/^https?:\/\//iu.test(remote.entry) && void 0 !== options.runtime) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} cannot use a custom runtime for network entry execution.`);
-        const loaded = await (0, load_js_namespaceObject.loadBackendFederatedEffectApi)({
+        const deliveryUnit = (0, external_metadata_js_namespaceObject.manifestDeliveryUnit)((0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest), (0, external_metadata_js_namespaceObject.versionBoundaryMetadata)(manifest));
+        const unitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
+        const buildMarker = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker);
+        if (!unitId || !buildMarker) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', 'Backend federation manifest requires delivery-unit identity.');
+        const loaded = await settleOnSharedAbort((0, load_js_namespaceObject.loadBackendFederatedEffectApi)({
             hostName: options.hostName,
             remote,
             ...options.plugins ? {
                 plugins: options.plugins
             } : {},
+            ...options.shared ? {
+                shared: options.shared
+            } : {},
             entryPolicy: {
                 ...options.entryPolicy,
                 signal: scope.signal,
@@ -141,16 +172,13 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
             ...options.runtime ? {
                 runtime: options.runtime
             } : {},
-            ...options.expected?.unitId && options.expected.buildMarker ? {
-                expected: {
-                    unitId: options.expected.unitId,
-                    buildMarker: options.expected.buildMarker
-                },
-                allowMissingIdentityMetadata: true
-            } : {}
+            expected: {
+                unitId,
+                buildMarker
+            }
         }).catch((error)=>{
             throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError(scope?.timedOut() === true ? 'timeout' : (0, external_validation_js_namespaceObject.classifyLoadError)(error), `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? index_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE}.`, error);
-        });
+        }), scope.signal);
         (0, external_validation_js_namespaceObject.validateLoadedBackendFederationContract)(loaded, manifest, remote);
         return loaded;
     } catch (error) {

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

@@ -37,7 +37,7 @@ __webpack_require__.d(__webpack_exports__, {
     stringValue: ()=>stringValue,
     versionBoundaryMetadata: ()=>versionBoundaryMetadata
 });
-const universal_namespaceObject = require("@modern-js/utils/universal");
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 function stringValue(value) {
     return 'string' == typeof value && value.length > 0 ? value : void 0;
 }
@@ -64,10 +64,10 @@ function resolveRemoteEntryFromMetadata(manifest) {
     ].filter(Boolean).join('/');
 }
 function backendFederationMetadata(manifest) {
-    return (0, universal_namespaceObject.backendFederationMetadata)(manifest);
+    return (0, backend_federation_contracts_namespaceObject.backendFederationMetadata)(manifest);
 }
 function versionBoundaryMetadata(manifest) {
-    return (0, universal_namespaceObject.backendFederationVersionBoundary)(manifest);
+    return (0, backend_federation_contracts_namespaceObject.backendFederationVersionBoundary)(manifest);
 }
 function deliveryUnitMetadata(record) {
     return recordField(record, 'deliveryUnit');

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

@@ -31,10 +31,12 @@ __webpack_require__.d(__webpack_exports__, {
     loadBackendFederatedEffectApiFromManifest: ()=>loadBackendFederatedEffectApiFromManifest
 });
 const node_namespaceObject = require("@modern-js/server-runtime-extensions/backend-federation-security/node");
+const node_shared_js_namespaceObject = require("../backend-federation/node-shared.js");
 const external_load_js_namespaceObject = require("./load.js");
-function loadBackendFederatedEffectApiFromManifest(options) {
+async function loadBackendFederatedEffectApiFromManifest(options) {
     return (0, external_load_js_namespaceObject.loadBackendFederatedEffectApiFromManifest)({
         ...options,
+        shared: (0, node_shared_js_namespaceObject.withEffectBffHostShared)(options.shared),
         entryPolicy: {
             ...options.entryPolicy,
             evaluateCommonJs: options.entryPolicy?.evaluateCommonJs ?? node_namespaceObject.evaluateNodeBackendFederationCommonJs

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

@@ -30,8 +30,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     resolveBackendFederationRemoteFromManifest: ()=>resolveBackendFederationRemoteFromManifest
 });
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const backend_federation_security_namespaceObject = require("@modern-js/server-runtime-extensions/backend-federation-security");
-const universal_namespaceObject = require("@modern-js/utils/universal");
 const index_js_namespaceObject = require("../backend-federation/index.js");
 const external_errors_js_namespaceObject = require("./errors.js");
 const external_metadata_js_namespaceObject = require("./metadata.js");
@@ -44,7 +44,7 @@ function resolveBackendFederationRemoteFromManifest(manifest, remoteOverride = {
     const manifestEntryUrl = (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.containerEntry) ?? (0, external_metadata_js_namespaceObject.stringValue)(entry?.url) ?? (0, external_metadata_js_namespaceObject.resolveRemoteEntryFromMetadata)(manifest);
     const remoteEntryUrl = remoteOverride.entry ?? manifestEntryUrl;
     const remoteType = remoteOverride.type ?? (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.remoteType) ?? (0, external_metadata_js_namespaceObject.stringValue)(entry?.type) ?? (0, external_metadata_js_namespaceObject.stringValue)(remoteEntry?.type) ?? 'module';
-    const expose = remoteOverride.expose ?? (0, universal_namespaceObject.backendFederationExposeNames)(backendFederation)[0] ?? index_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
+    const expose = remoteOverride.expose ?? (0, backend_federation_contracts_namespaceObject.backendFederationExposeNames)(backendFederation)[0] ?? index_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
     let verification;
     try {
         const manifestVerification = (0, backend_federation_security_namespaceObject.resolveBackendFederationRemoteEntryVerification)(manifest);
@@ -63,13 +63,7 @@ function resolveBackendFederationRemoteFromManifest(manifest, remoteOverride = {
         ...verification ? {
             verification
         } : {},
-        ...remoteOverride.entryGlobalName ? {
-            entryGlobalName: remoteOverride.entryGlobalName
-        } : {},
-        expose,
-        ...remoteOverride.shareScope ? {
-            shareScope: remoteOverride.shareScope
-        } : {}
+        expose
     };
 }
 exports.resolveBackendFederationRemoteFromManifest = __webpack_exports__.resolveBackendFederationRemoteFromManifest;

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

@@ -32,8 +32,9 @@ __webpack_require__.d(__webpack_exports__, {
     validateBackendFederationManifest: ()=>validateBackendFederationManifest,
     validateLoadedBackendFederationContract: ()=>validateLoadedBackendFederationContract
 });
-const universal_namespaceObject = require("@modern-js/utils/universal");
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const index_js_namespaceObject = require("../backend-federation/index.js");
+const identity_js_namespaceObject = require("../backend-federation/identity.js");
 const external_errors_js_namespaceObject = require("./errors.js");
 const external_metadata_js_namespaceObject = require("./metadata.js");
 function resolveExpectedBuildMarker(expected) {
@@ -48,12 +49,11 @@ function validateBackendFederationManifest(manifest, expected = {}) {
     const expectedBuildMarker = resolveExpectedBuildMarker(expected);
     const backendFederation = (0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest);
     (0, external_errors_js_namespaceObject.assertManifestAdapter)(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
-    const manifestShape = (0, universal_namespaceObject.validateBackendFederationManifest)(manifest, {
+    const manifestShape = (0, backend_federation_contracts_namespaceObject.validateBackendFederationManifest)(manifest, {
         expectedContractVersion: false,
-        expectedNodeAdapterVersion: false,
-        validateDeliveryUnit: false
+        expectedNodeAdapterVersion: false
     });
-    (0, external_errors_js_namespaceObject.assertManifestAdapter)(manifestShape.ok, 'manifest_invalid', `[BFF][Effect] Backend federation manifest schema invalid: ${(0, universal_namespaceObject.formatBackendFederationValidationErrors)(manifestShape.errors)}.`);
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(manifestShape.ok, 'manifest_invalid', `[BFF][Effect] Backend federation manifest schema invalid: ${(0, backend_federation_contracts_namespaceObject.formatBackendFederationValidationErrors)(manifestShape.errors)}.`);
     (0, external_errors_js_namespaceObject.assertManifestAdapter)('effect' === backendFederation.runtimeFramework, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare runtimeFramework: "effect".');
     (0, external_errors_js_namespaceObject.assertManifestAdapter)(true === backendFederation.strictEffectApproach, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare strictEffectApproach: true.');
     (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(backendFederation.contractVersion), expected.contractVersion ?? index_js_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION, 'manifest contractVersion');
@@ -69,6 +69,7 @@ function validateBackendFederationManifest(manifest, expected = {}) {
     (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'versionBoundary.deliveryUnit.buildMarker vs versionBoundary.buildVersion');
     (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId), (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId), 'backendFederation.deliveryUnit.unitId vs versionBoundary.deliveryUnit.unitId');
     const manifestUnitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(manifestUnitId && (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), 'manifest_invalid', 'Backend federation manifest requires delivery-unit unitId and buildMarker.');
     (0, external_errors_js_namespaceObject.assertVersionValue)(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
     (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
 }
@@ -76,19 +77,22 @@ function validateLoadedBackendFederationContract(loaded, manifest, remote) {
     const loadedContract = loaded.backendFederationContract;
     const backendFederation = (0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest);
     const boundary = (0, external_metadata_js_namespaceObject.versionBoundaryMetadata)(manifest);
-    const compatibility = (0, external_metadata_js_namespaceObject.recordField)(loadedContract, 'compatibility');
+    const compatibility = (0, identity_js_namespaceObject.backendFederationCompatibility)(loaded);
     (0, external_errors_js_namespaceObject.assertManifestAdapter)(compatibility, 'version_mismatch', `[BFF][Effect] Backend federation expose ${remote.name}/${remote.expose?.replace(/^\.\//u, '')} must declare compatibility metadata.`);
     (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(loadedContract?.role), 'microvertical-server', 'expose role');
     (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(loadedContract?.name), remote.name, 'expose name');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.contractVersion), (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.contractVersion), 'expose contractVersion');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.nodeAdapterVersion), (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.nodeAdapterVersion), 'expose nodeAdapterVersion');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.packageName), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName), 'expose packageName');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'expose buildVersion');
     const deliveryUnit = (0, external_metadata_js_namespaceObject.manifestDeliveryUnit)(backendFederation, boundary);
     const manifestUnitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
     const manifestBuildMarker = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker);
-    (0, external_errors_js_namespaceObject.assertConsistentValue)(manifestUnitId, (0, external_metadata_js_namespaceObject.stringValue)(compatibility.unitId), 'deliveryUnit.unitId vs expose compatibility.unitId');
-    (0, external_errors_js_namespaceObject.assertConsistentValue)(manifestBuildMarker, (0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), 'deliveryUnit.buildMarker vs expose compatibility.build');
+    const issues = (0, identity_js_namespaceObject.validateBackendFederationCompatibility)(compatibility, {
+        contractVersion: (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.contractVersion),
+        nodeAdapterVersion: (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.nodeAdapterVersion),
+        packageName: (0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName),
+        unitId: manifestUnitId,
+        build: manifestBuildMarker ?? (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion)
+    });
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'expose buildVersion');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(0 === issues.length, 'version_mismatch', `[BFF][Effect] ${(0, identity_js_namespaceObject.formatBackendFederationIdentityIssues)(issues)}.`);
 }
 function classifyLoadError(error) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/cjs/cross-project-policy/evaluation.js

@@ -31,13 +31,13 @@ __webpack_require__.d(__webpack_exports__, {
     checkCrossProjectPolicyForRequest: ()=>checkCrossProjectPolicyForRequest,
     checkCrossProjectPolicyResponse: ()=>checkCrossProjectPolicyResponse
 });
-const cross_project_policy_namespaceObject = require("@modern-js/bff-core/security/cross-project-policy");
+const bff_policy_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy");
 const DENIAL_HEADERS = {
     'content-type': 'application/json; charset=utf-8'
 };
 const checkCrossProjectPolicyResponse = (headers, policy, observedRequest)=>{
     if (!policy?.enabled) return null;
-    const violation = (0, cross_project_policy_namespaceObject.evaluateCrossProjectPolicy)(headers, policy, observedRequest);
+    const violation = (0, bff_policy_namespaceObject.evaluateCrossProjectPolicy)(headers, policy, observedRequest);
     if (!violation) return null;
     return new Response(JSON.stringify({
         code: violation.code,
@@ -54,7 +54,7 @@ const checkCrossProjectPolicyForRequest = (request, policy)=>{
         method: request.method,
         pathname: new URL(request.url).pathname
     };
-    const observedRequest = (0, cross_project_policy_namespaceObject.resolveCrossProjectRequestObservation)(requestTarget, policy) ?? {
+    const observedRequest = (0, bff_policy_namespaceObject.resolveCrossProjectRequestObservation)(requestTarget, policy) ?? {
         method: requestTarget.method,
         routePath: requestTarget.pathname
     };

package/dist/cjs/cross-project-policy/node.js

@@ -1,14 +1,5 @@
 "use strict";
 var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -39,32 +30,22 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     resolveAdapterCrossProjectPolicy: ()=>resolveAdapterCrossProjectPolicy
 });
-const external_node_fs_namespaceObject = require("node:fs");
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const bff_core_namespaceObject = require("@modern-js/bff-core");
-const readNearestPackageVersion = (startDir)=>{
-    if (!startDir) return;
-    let current = external_node_path_default().resolve(startDir);
-    for(let depth = 0; depth < 10; depth += 1){
-        try {
-            const packageJson = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(external_node_path_default().join(current, 'package.json'), 'utf8'));
-            if ('string' == typeof packageJson.version) return packageJson.version;
-        } catch  {}
-        const parent = external_node_path_default().dirname(current);
-        if (parent === current) break;
-        current = parent;
-    }
-};
-const resolveAdapterCrossProjectPolicy = (api, handlers)=>{
+require("@modern-js/server-runtime-extensions/server-config");
+const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
+const resolveAdapterCrossProjectPolicy = (api, handlers, producer)=>{
     const bff = api.getServerConfig()?.bff;
     const { apiDirectory, appDirectory } = api.getServerContext();
-    return (0, bff_core_namespaceObject.resolveCrossProjectPolicy)({
+    return (0, node_namespaceObject.resolveCrossProjectPolicy)({
         crossProjectPolicy: bff?.crossProjectPolicy,
         handlers,
-        requestId: bff?.requestId,
         isCrossProjectServer: bff?.isCrossProjectServer,
-        operationVersion: (0, bff_core_namespaceObject.deriveOperationVersion)(readNearestPackageVersion(apiDirectory) ?? readNearestPackageVersion(appDirectory))
+        ...producer ?? (0, node_namespaceObject.resolveOperationProducer)({
+            directories: [
+                apiDirectory,
+                appDirectory
+            ],
+            requestId: bff?.requestId || 'default'
+        })
     });
 };
 exports.resolveAdapterCrossProjectPolicy = __webpack_exports__.resolveAdapterCrossProjectPolicy;

package/dist/cjs/{backend-federation/legacy-warning.js → cross-project-policy/producer-runtime.js}

@@ -27,13 +27,31 @@ var __webpack_require__ = {};
 })();
 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
+function createProducerClient(configure, { requestId }) {
+    return (options)=>configure({
+            requestId,
+            requireEnvelope: true,
+            ...options,
+            identityBinding: {
+                enabled: true,
+                strict: true,
+                ...options?.identityBinding
+            },
+            operationContract: {
+                enabled: true,
+                strict: true,
+                requireSchemaHash: true,
+                requireOperationVersion: true,
+                ...options?.operationContract
+            }
+        });
+}
+__webpack_require__.d(__webpack_exports__, {
+    createProducerClient: ()=>createProducerClient
 });
-exports.LEGACY_LOAD_WARNING = __webpack_exports__.LEGACY_LOAD_WARNING;
+exports.createProducerClient = __webpack_exports__.createProducerClient;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "LEGACY_LOAD_WARNING"
+    "createProducerClient"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/{effect-adapter → effect-server}/cross-project-policy.js

@@ -28,13 +28,13 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    resolveEffectAdapterCrossProjectPolicy: ()=>resolveEffectAdapterCrossProjectPolicy
+    resolveEffectServerCrossProjectPolicy: ()=>resolveEffectServerCrossProjectPolicy
 });
 const effect_namespaceObject = require("@modern-js/bff-effect/effect");
 const utils_namespaceObject = require("@modern-js/utils");
 const httpapi_namespaceObject = require("effect/unstable/httpapi");
 const index_js_namespaceObject = require("../cross-project-policy/index.js");
-function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
+function resolveEffectServerCrossProjectPolicy(api, prefix, mod, producer) {
     const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>(0, effect_namespaceObject.extractHttpApiFromModule)(mod, httpapi_namespaceObject.HttpApi.isHttpApi)).then((effectApi)=>{
         if (null === effectApi) return [];
         const reflect = (apiValue, handlers)=>{
@@ -50,14 +50,14 @@ function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
         return [];
     });
     return contractSourcesPromise.then((contractSources)=>{
-        const policy = (0, index_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources);
+        const policy = (0, index_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources, producer);
         if (policy?.enabled === true && 0 === contractSources.length) utils_namespaceObject.logger.warn('[BFF][Effect] Cross-project policy enabled but no HttpApi endpoints could be reflected; requests fail operation-contract matching unless allowUnknownOperations is enabled.');
         return policy;
     });
 }
-exports.resolveEffectAdapterCrossProjectPolicy = __webpack_exports__.resolveEffectAdapterCrossProjectPolicy;
+exports.resolveEffectServerCrossProjectPolicy = __webpack_exports__.resolveEffectServerCrossProjectPolicy;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "resolveEffectAdapterCrossProjectPolicy"
+    "resolveEffectServerCrossProjectPolicy"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/effect-server/entry.js

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    resolveEffectServerEntryFile: ()=>resolveEffectServerEntryFile
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+require("@modern-js/server-runtime-extensions/server-config");
+const utils_namespaceObject = require("@modern-js/utils");
+const paths_js_namespaceObject = require("../effect-source-loader/paths.js");
+function resolveEffectServerEntryFile(api) {
+    const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
+    const appDir = external_node_path_default().resolve(appDirectory || process.cwd());
+    return (0, paths_js_namespaceObject.resolveEffectEntry)({
+        appDir,
+        apiDir: external_node_path_default().resolve(appDir, apiDirectory || utils_namespaceObject.API_DIR),
+        effectEntry: api.getServerConfig()?.bff?.effect?.entry,
+        distDir: (0, utils_namespaceObject.isProd)() && distDirectory ? external_node_path_default().resolve(distDirectory) : void 0
+    }).path;
+}
+exports.resolveEffectServerEntryFile = __webpack_exports__.resolveEffectServerEntryFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveEffectServerEntryFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/{effect-adapter → effect-server}/error-response.js

@@ -28,11 +28,11 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createEffectAdapterRuntimeErrorResponse: ()=>createEffectAdapterRuntimeErrorResponse
+    createEffectServerRuntimeErrorResponse: ()=>createEffectServerRuntimeErrorResponse
 });
 const safe_failure_namespaceObject = require("@modern-js/runtime-extensions/safe-failure");
 const utils_namespaceObject = require("@modern-js/utils");
-function createEffectAdapterRuntimeErrorResponse(api, error, context) {
+function createEffectServerRuntimeErrorResponse(api, error, context) {
     try {
         const onError = api.getServerConfig()?.onError;
         if (void 0 !== onError) return Promise.resolve(onError(error instanceof Error ? error : new Error(String(error)), ensureJsonContext(context))).then((result)=>result instanceof Response ? result : (0, safe_failure_namespaceObject.createSafeFailureResponse)(error)).catch((configError)=>{
@@ -66,9 +66,9 @@ function ensureJsonContext(context) {
         }
     });
 }
-exports.createEffectAdapterRuntimeErrorResponse = __webpack_exports__.createEffectAdapterRuntimeErrorResponse;
+exports.createEffectServerRuntimeErrorResponse = __webpack_exports__.createEffectServerRuntimeErrorResponse;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createEffectAdapterRuntimeErrorResponse"
+    "createEffectServerRuntimeErrorResponse"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true