@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/README.md

@@ -1,7 +1,7 @@
 # @modern-js/plugin-bff-extensions
 
 Fork-owned integration extensions for UltraModern.js BFFs. This package keeps
-Effect adapter lifecycle integration, source and client generation,
+Effect adapter lifecycle integration, server source loading,
 cross-project policy, Hono middleware, and backend federation out of the
 upstream-owned `@modern-js/plugin-bff` implementation.
 
@@ -12,8 +12,7 @@ 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-policy`, `/effect-adapter`, and `/effect-source-loader` 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
@@ -22,8 +21,19 @@ upstream Modern.js project.
 - `/backend-federation-manifest` exposes manifest contracts and resolution,
   while
   `/backend-federation-manifest/node` enables its hardened Node evaluator.
+  `loadBackendFederatedEffectApiFromManifest` enforces one shared
+  manifest-plus-entry load deadline (default 10s, override via `timeoutMs`,
+  0 to opt out) instead of resetting a fresh timeout per network hop. The
+  load settles on that shared deadline/abort even when a caller-pinned
+  `loadEntry` plugin, its `init`/`get`, or a custom runtime's `loadRemote`
+  never settles; it cannot stop that uncooperative work from still running,
+  only stop waiting on it.
 
 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.
+
+Effect server tooling derives operation-contract metadata without generating
+client code. Import shared `HttpApi` contracts in clients and use native
+`HttpApiClient.make`; the former `/client-generator` entry point is removed.

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

@@ -29,8 +29,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createBackendFederationLoadEntryPlugin: ()=>createBackendFederationLoadEntryPlugin,
-    createBackendFederationRuntime: ()=>createBackendFederationRuntime,
-    createBackendFederationRuntimeForLoad: ()=>createBackendFederationRuntimeForLoad
+    createBackendFederationRuntime: ()=>createBackendFederationRuntime
 });
 const external_validate_loaded_js_namespaceObject = require("./validate-loaded.js");
 function _check_private_redeclaration(obj, privateCollection) {
@@ -100,7 +99,7 @@ async function resolveEdgeEntry(plugins, remote) {
     }
     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();
+var _entries = /*#__PURE__*/ new WeakMap(), _expected = /*#__PURE__*/ new WeakMap(), _hostName = /*#__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);
@@ -127,10 +126,6 @@ class EdgeBackendFederationRuntime {
             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
@@ -146,7 +141,6 @@ class EdgeBackendFederationRuntime {
         _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 ?? []);
@@ -185,7 +179,6 @@ function loadModule(request) {
         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
@@ -214,16 +207,11 @@ 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"
+    "createBackendFederationRuntime"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -28,30 +28,29 @@ var __webpack_require__ = {};
 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,
+    BACKEND_FEDERATION_CONTRACT_VERSION: ()=>backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION,
+    BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE,
+    BACKEND_FEDERATION_MANIFEST_FILE: ()=>backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+    BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>backend_federation_contracts_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 backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 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;
+    if (!options.expected?.unitId || !options.expected.buildMarker) return Promise.reject(new Error('[BFF][Effect] Backend federation requires expected.unitId and expected.buildMarker.'));
+    const expose = options.expose ?? options.remote?.expose ?? backend_federation_contracts_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);
+        runtime = (0, external_edge_runtime_js_namespaceObject.createBackendFederationRuntime)(options);
     } catch (error) {
         return Promise.reject(error);
     }

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

@@ -32,37 +32,31 @@ __webpack_require__.d(__webpack_exports__, {
     validateExpectedBackendFederationIdentity: ()=>validateExpectedBackendFederationIdentity
 });
 const external_utils_js_namespaceObject = require("./utils.js");
-function validateExpectedBackendFederationIdentity(loaded, expected, options = {}) {
-    const allowMissing = true === options.allowMissingIdentityMetadata;
+function validateExpectedBackendFederationIdentity(loaded, expected) {
     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'
-            }
-        ];
-    }
+    if (!(0, external_utils_js_namespaceObject.isRecord)(compatibility)) 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({
+    if ('string' != typeof unitId || 0 === unitId.length) 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({
+    if ('string' != typeof build || 0 === build.length) 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}`
     });

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

@@ -28,15 +28,15 @@ var __webpack_require__ = {};
 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,
+    BACKEND_FEDERATION_CONTRACT_VERSION: ()=>backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION,
+    BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE,
+    BACKEND_FEDERATION_MANIFEST_FILE: ()=>backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+    BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>backend_federation_contracts_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 backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const external_identity_js_namespaceObject = require("./identity.js");
 const external_plugin_js_namespaceObject = require("./plugin.js");
 const external_runtime_js_namespaceObject = require("./runtime.js");

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

@@ -30,34 +30,24 @@ __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 backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 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 (!options.expected?.unitId || !options.expected.buildMarker) return Promise.reject(new Error('[BFF][Effect] Backend federation requires expected.unitId and expected.buildMarker.'));
     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 expose = options.expose ?? options.remote?.expose ?? backend_federation_contracts_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

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,7 +151,11 @@ 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 ? {
@@ -141,16 +169,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/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);

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

@@ -32,7 +32,7 @@ __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 external_errors_js_namespaceObject = require("./errors.js");
 const external_metadata_js_namespaceObject = require("./metadata.js");
@@ -48,12 +48,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 +68,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');
 }
@@ -87,8 +87,8 @@ function validateLoadedBackendFederationContract(loaded, manifest, remote) {
     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');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.unitId), manifestUnitId, 'deliveryUnit.unitId vs expose compatibility.unitId');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), manifestBuildMarker, 'deliveryUnit.buildMarker vs expose compatibility.build');
 }
 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

@@ -42,7 +42,8 @@ __webpack_require__.d(__webpack_exports__, {
 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");
+require("@modern-js/server-runtime-extensions/server-config");
+const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
 const readNearestPackageVersion = (startDir)=>{
     if (!startDir) return;
     let current = external_node_path_default().resolve(startDir);
@@ -59,12 +60,12 @@ const readNearestPackageVersion = (startDir)=>{
 const resolveAdapterCrossProjectPolicy = (api, handlers)=>{
     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))
+        operationVersion: (0, node_namespaceObject.deriveOperationVersion)(readNearestPackageVersion(apiDirectory) ?? readNearestPackageVersion(appDirectory))
     });
 };
 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/entry.js

@@ -41,6 +41,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 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 JS_OR_TS_EXTS = [
     '.js',

package/dist/cjs/effect-adapter/index.js

@@ -37,10 +37,12 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    EffectAdapter: ()=>EffectAdapter
+    EffectAdapter: ()=>EffectAdapter,
+    createRuntimeAdapters: ()=>createRuntimeAdapters
 });
 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 effect_namespaceObject = require("@modern-js/bff-effect/effect");
 const runtime_lifecycle_namespaceObject = require("@modern-js/server-runtime-extensions/runtime-lifecycle");
 const utils_namespaceObject = require("@modern-js/utils");
@@ -178,9 +180,14 @@ class EffectAdapter {
         this.api = api;
     }
 }
+const createRuntimeAdapters = (api)=>[
+        new EffectAdapter(api)
+    ];
 exports.EffectAdapter = __webpack_exports__.EffectAdapter;
+exports.createRuntimeAdapters = __webpack_exports__.createRuntimeAdapters;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "EffectAdapter"
+    "EffectAdapter",
+    "createRuntimeAdapters"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/{client-generator → effect-source-loader}/built-entry.js

@@ -51,7 +51,7 @@ async function bundleBuiltEffectEntryForNode(options) {
     });
     const builtEntry = resolveBuiltEffectEntry(appDir, distDir, sourceEntry);
     if (void 0 === builtEntry || 0 === builtEntry.length) throw new Error(`Effect BFF entry was not emitted into ${distDir}: ${sourceEntry ?? utils_namespaceObject.upath.resolve(apiDir, 'index')}`);
-    const { bundleEffectEntryForNode } = await import("../effect-source-loader/loader.js");
+    const { bundleEffectEntryForNode } = await import("./loader.js");
     return bundleEffectEntryForNode({
         appDir,
         entryPath: builtEntry,