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

package/dist/esm/backend-federation/runtime.mjs

@@ -1,90 +1,22 @@
 import { ModuleFederation } from "@module-federation/runtime";
-import { loadBackendFederationExpose } from "./entry.mjs";
-import { createBackendFederationLoadEntryPlugin } from "./plugin.mjs";
+import { createBackendFederationIntegrityPlugin } from "./integrity-plugin.mjs";
 import { collectRemotes } from "./remotes.mjs";
-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 createBackendFederationLoadEntryPlugin({
-        resolveEntry (resolvedRemote) {
-            const remote = remotes.find((candidate)=>candidate.name === resolvedRemote.name);
-            if (void 0 === remote) return;
-            return {
-                get (expose) {
-                    return ()=>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 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 = collectRemotes(options);
-    return new BackendFederationRuntime(options, remotes);
+    return new ModuleFederation({
+        name: options.hostName,
+        remotes: remotes.map(({ name, entry, type })=>({
+                name,
+                entry,
+                ...type ? {
+                    type
+                } : {}
+            })),
+        shared: options.shared ?? {},
+        plugins: [
+            ...options.plugins ?? [],
+            createBackendFederationIntegrityPlugin(options, remotes)
+        ]
+    });
 }
 export { createBackendFederationRuntime };

package/dist/esm/backend-federation/validate-loaded.mjs

@@ -7,10 +7,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 = validateExpectedBackendFederationIdentity(loaded, options.expected, {
-            allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
-        });
+    {
+        const issues = validateExpectedBackendFederationIdentity(loaded, options.expected);
         if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} delivery-unit identity mismatch: ${formatBackendFederationIdentityIssues(issues)}.`);
     }
     return loaded;

package/dist/esm/backend-federation-manifest/load.mjs

@@ -1,9 +1,11 @@
 import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "../backend-federation/index.mjs";
 import { loadBackendFederatedEffectApi } from "../backend-federation/load.mjs";
 import { BackendFederationManifestAdapterError } from "./errors.mjs";
+import { backendFederationMetadata, manifestDeliveryUnit, stringValue, versionBoundaryMetadata } from "./metadata.mjs";
 import { loadBackendFederationManifest } from "./reference.mjs";
 import { resolveBackendFederationRemoteFromManifest } from "./remote.mjs";
 import { classifyLoadError, validateBackendFederationManifest, validateLoadedBackendFederationContract } from "./validation.mjs";
+const DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS = 10000;
 function createManifestLoadScope(options) {
     const controller = new AbortController();
     const policyTimeouts = [
@@ -15,7 +17,8 @@ function createManifestLoadScope(options) {
         ...policyTimeouts
     ].filter((timeout)=>void 0 !== timeout);
     for (const timeout of configuredTimeouts)if (!Number.isSafeInteger(timeout) || timeout < 0) throw new 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,
@@ -69,6 +72,27 @@ function isCallerPinnedStaticRemote(options, remote) {
 function throwIfManifestLoadAborted(signal) {
     if (signal.aborted) throw new 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 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;
@@ -76,7 +100,7 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
     try {
         scope = createManifestLoadScope(options);
         throwIfManifestLoadAborted(scope.signal);
-        manifest = await loadBackendFederationManifest({
+        manifest = await settleOnSharedAbort(loadBackendFederationManifest({
             ...options,
             manifestPolicy: {
                 ...options.manifestPolicy,
@@ -85,7 +109,7 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
             },
             signal: scope.signal,
             timeoutMs: 0
-        });
+        }), scope.signal);
         validateBackendFederationManifest(manifest, options.expected);
         remote = resolveBackendFederationRemoteFromManifest(manifest, options.remote);
         throwIfManifestLoadAborted(scope.signal);
@@ -95,12 +119,19 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
         if (remoteManifest && /^https?:\/\//iu.test(remote.entry) && !hasPinnedRemoteEntryExpectation(options)) throw new 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 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 BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} cannot use a custom runtime for network entry execution.`);
-        const loaded = await loadBackendFederatedEffectApi({
+        const deliveryUnit = manifestDeliveryUnit(backendFederationMetadata(manifest), versionBoundaryMetadata(manifest));
+        const unitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
+        const buildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
+        if (!unitId || !buildMarker) throw new BackendFederationManifestAdapterError('manifest_invalid', 'Backend federation manifest requires delivery-unit identity.');
+        const loaded = await settleOnSharedAbort(loadBackendFederatedEffectApi({
             hostName: options.hostName,
             remote,
             ...options.plugins ? {
                 plugins: options.plugins
             } : {},
+            ...options.shared ? {
+                shared: options.shared
+            } : {},
             entryPolicy: {
                 ...options.entryPolicy,
                 signal: scope.signal,
@@ -109,16 +140,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 BackendFederationManifestAdapterError(scope?.timedOut() === true ? 'timeout' : classifyLoadError(error), `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE}.`, error);
-        });
+        }), scope.signal);
         validateLoadedBackendFederationContract(loaded, manifest, remote);
         return loaded;
     } catch (error) {

package/dist/esm/backend-federation-manifest/metadata.mjs

@@ -1,4 +1,4 @@
-import { backendFederationMetadata, backendFederationVersionBoundary } from "@modern-js/utils/universal";
+import { backendFederationMetadata, backendFederationVersionBoundary } from "@modern-js/backend-federation-contracts";
 function stringValue(value) {
     return 'string' == typeof value && value.length > 0 ? value : void 0;
 }

package/dist/esm/backend-federation-manifest/node.mjs

@@ -1,8 +1,10 @@
 import { evaluateNodeBackendFederationCommonJs } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
+import { withEffectBffHostShared } from "../backend-federation/node-shared.mjs";
 import { loadBackendFederatedEffectApiFromManifest } from "./load.mjs";
-function node_loadBackendFederatedEffectApiFromManifest(options) {
+async function node_loadBackendFederatedEffectApiFromManifest(options) {
     return loadBackendFederatedEffectApiFromManifest({
         ...options,
+        shared: withEffectBffHostShared(options.shared),
         entryPolicy: {
             ...options.entryPolicy,
             evaluateCommonJs: options.entryPolicy?.evaluateCommonJs ?? evaluateNodeBackendFederationCommonJs

package/dist/esm/backend-federation-manifest/remote.mjs

@@ -1,5 +1,5 @@
+import { backendFederationExposeNames } from "@modern-js/backend-federation-contracts";
 import { BackendFederationRemoteEntryError, resolveBackendFederationRemoteEntryVerification } from "@modern-js/server-runtime-extensions/backend-federation-security";
-import { backendFederationExposeNames } from "@modern-js/utils/universal";
 import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "../backend-federation/index.mjs";
 import { BackendFederationManifestAdapterError, assertManifestAdapter } from "./errors.mjs";
 import { backendFederationMetadata, recordField, resolveRemoteEntryFromMetadata, stringValue } from "./metadata.mjs";
@@ -31,13 +31,7 @@ function resolveBackendFederationRemoteFromManifest(manifest, remoteOverride = {
         ...verification ? {
             verification
         } : {},
-        ...remoteOverride.entryGlobalName ? {
-            entryGlobalName: remoteOverride.entryGlobalName
-        } : {},
-        expose,
-        ...remoteOverride.shareScope ? {
-            shareScope: remoteOverride.shareScope
-        } : {}
+        expose
     };
 }
 export { resolveBackendFederationRemoteFromManifest };

package/dist/esm/backend-federation-manifest/validation.mjs

@@ -1,7 +1,8 @@
-import { formatBackendFederationValidationErrors, validateBackendFederationManifest } from "@modern-js/utils/universal";
+import { formatBackendFederationValidationErrors, validateBackendFederationManifest } from "@modern-js/backend-federation-contracts";
 import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "../backend-federation/index.mjs";
+import { backendFederationCompatibility, formatBackendFederationIdentityIssues, validateBackendFederationCompatibility } from "../backend-federation/identity.mjs";
 import { BackendFederationManifestAdapterError, assertConsistentValue, assertManifestAdapter, assertVersionValue } from "./errors.mjs";
-import { backendFederationMetadata, manifestDeliveryUnit, recordField, stringValue, versionBoundaryMetadata } from "./metadata.mjs";
+import { backendFederationMetadata, manifestDeliveryUnit, stringValue, versionBoundaryMetadata } from "./metadata.mjs";
 function resolveExpectedBuildMarker(expected) {
     if (void 0 !== expected.buildVersion && void 0 !== expected.buildMarker && expected.buildVersion !== expected.buildMarker) throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation expected buildVersion/buildMarker mismatch: buildVersion ${expected.buildVersion}, buildMarker ${expected.buildMarker}.`, void 0, {
         label: 'expected.buildVersion/buildMarker',
@@ -16,8 +17,7 @@ function validation_validateBackendFederationManifest(manifest, expected = {}) {
     assertManifestAdapter(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
     const manifestShape = validateBackendFederationManifest(manifest, {
         expectedContractVersion: false,
-        expectedNodeAdapterVersion: false,
-        validateDeliveryUnit: false
+        expectedNodeAdapterVersion: false
     });
     assertManifestAdapter(manifestShape.ok, 'manifest_invalid', `[BFF][Effect] Backend federation manifest schema invalid: ${formatBackendFederationValidationErrors(manifestShape.errors)}.`);
     assertManifestAdapter('effect' === backendFederation.runtimeFramework, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare runtimeFramework: "effect".');
@@ -35,6 +35,7 @@ function validation_validateBackendFederationManifest(manifest, expected = {}) {
     assertConsistentValue(stringValue(deliveryUnit.boundary?.buildMarker), stringValue(boundary?.buildVersion), 'versionBoundary.deliveryUnit.buildMarker vs versionBoundary.buildVersion');
     assertConsistentValue(stringValue(deliveryUnit.top?.unitId), stringValue(deliveryUnit.boundary?.unitId), 'backendFederation.deliveryUnit.unitId vs versionBoundary.deliveryUnit.unitId');
     const manifestUnitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
+    assertManifestAdapter(manifestUnitId && stringValue(deliveryUnit.boundary?.buildMarker), 'manifest_invalid', 'Backend federation manifest requires delivery-unit unitId and buildMarker.');
     assertVersionValue(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
     assertVersionValue(stringValue(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
 }
@@ -42,19 +43,22 @@ function validateLoadedBackendFederationContract(loaded, manifest, remote) {
     const loadedContract = loaded.backendFederationContract;
     const backendFederation = backendFederationMetadata(manifest);
     const boundary = versionBoundaryMetadata(manifest);
-    const compatibility = recordField(loadedContract, 'compatibility');
+    const compatibility = backendFederationCompatibility(loaded);
     assertManifestAdapter(compatibility, 'version_mismatch', `[BFF][Effect] Backend federation expose ${remote.name}/${remote.expose?.replace(/^\.\//u, '')} must declare compatibility metadata.`);
     assertVersionValue(stringValue(loadedContract?.role), 'microvertical-server', 'expose role');
     assertVersionValue(stringValue(loadedContract?.name), remote.name, 'expose name');
-    assertVersionValue(stringValue(compatibility.contractVersion), stringValue(backendFederation?.contractVersion), 'expose contractVersion');
-    assertVersionValue(stringValue(compatibility.nodeAdapterVersion), stringValue(backendFederation?.nodeAdapterVersion), 'expose nodeAdapterVersion');
-    assertVersionValue(stringValue(compatibility.packageName), stringValue(boundary?.packageName), 'expose packageName');
-    assertVersionValue(stringValue(compatibility.build), stringValue(boundary?.buildVersion), 'expose buildVersion');
     const deliveryUnit = manifestDeliveryUnit(backendFederation, boundary);
     const manifestUnitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
     const manifestBuildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
-    assertConsistentValue(manifestUnitId, stringValue(compatibility.unitId), 'deliveryUnit.unitId vs expose compatibility.unitId');
-    assertConsistentValue(manifestBuildMarker, stringValue(compatibility.build), 'deliveryUnit.buildMarker vs expose compatibility.build');
+    const issues = validateBackendFederationCompatibility(compatibility, {
+        contractVersion: stringValue(backendFederation?.contractVersion),
+        nodeAdapterVersion: stringValue(backendFederation?.nodeAdapterVersion),
+        packageName: stringValue(boundary?.packageName),
+        unitId: manifestUnitId,
+        build: manifestBuildMarker ?? stringValue(boundary?.buildVersion)
+    });
+    assertVersionValue(stringValue(compatibility.build), stringValue(boundary?.buildVersion), 'expose buildVersion');
+    assertManifestAdapter(0 === issues.length, 'version_mismatch', `[BFF][Effect] ${formatBackendFederationIdentityIssues(issues)}.`);
 }
 function classifyLoadError(error) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/esm/cross-project-policy/evaluation.mjs

@@ -1,4 +1,4 @@
-import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/bff-core/security/cross-project-policy";
+import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/server-runtime-extensions/bff-policy";
 const DENIAL_HEADERS = {
     'content-type': 'application/json; charset=utf-8'
 };

package/dist/esm/cross-project-policy/node.mjs

@@ -1,28 +1,19 @@
-import { readFileSync } from "node:fs";
-import node_path from "node:path";
-import { deriveOperationVersion, resolveCrossProjectPolicy } from "@modern-js/bff-core";
-const readNearestPackageVersion = (startDir)=>{
-    if (!startDir) return;
-    let current = node_path.resolve(startDir);
-    for(let depth = 0; depth < 10; depth += 1){
-        try {
-            const packageJson = JSON.parse(readFileSync(node_path.join(current, 'package.json'), 'utf8'));
-            if ('string' == typeof packageJson.version) return packageJson.version;
-        } catch  {}
-        const parent = node_path.dirname(current);
-        if (parent === current) break;
-        current = parent;
-    }
-};
-const resolveAdapterCrossProjectPolicy = (api, handlers)=>{
+import "@modern-js/server-runtime-extensions/server-config";
+import { resolveCrossProjectPolicy, resolveOperationProducer } from "@modern-js/server-runtime-extensions/bff-policy/node";
+const resolveAdapterCrossProjectPolicy = (api, handlers, producer)=>{
     const bff = api.getServerConfig()?.bff;
     const { apiDirectory, appDirectory } = api.getServerContext();
     return resolveCrossProjectPolicy({
         crossProjectPolicy: bff?.crossProjectPolicy,
         handlers,
-        requestId: bff?.requestId,
         isCrossProjectServer: bff?.isCrossProjectServer,
-        operationVersion: deriveOperationVersion(readNearestPackageVersion(apiDirectory) ?? readNearestPackageVersion(appDirectory))
+        ...producer ?? resolveOperationProducer({
+            directories: [
+                apiDirectory,
+                appDirectory
+            ],
+            requestId: bff?.requestId || 'default'
+        })
     });
 };
 export { resolveAdapterCrossProjectPolicy };

package/dist/esm/cross-project-policy/producer-runtime.mjs

@@ -0,0 +1,20 @@
+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
+            }
+        });
+}
+export { createProducerClient };

package/dist/esm/{effect-adapter → effect-server}/cross-project-policy.mjs

@@ -2,7 +2,7 @@ import { collectEffectEndpoints, extractHttpApiFromModule, toOperationContractSo
 import { logger } from "@modern-js/utils";
 import { HttpApi } from "effect/unstable/httpapi";
 import { resolveAdapterCrossProjectPolicy } from "../cross-project-policy/index.mjs";
-function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
+function resolveEffectServerCrossProjectPolicy(api, prefix, mod, producer) {
     const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>extractHttpApiFromModule(mod, HttpApi.isHttpApi)).then((effectApi)=>{
         if (null === effectApi) return [];
         const reflect = (apiValue, handlers)=>{
@@ -18,9 +18,9 @@ function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
         return [];
     });
     return contractSourcesPromise.then((contractSources)=>{
-        const policy = resolveAdapterCrossProjectPolicy(api, contractSources);
+        const policy = resolveAdapterCrossProjectPolicy(api, contractSources, producer);
         if (policy?.enabled === true && 0 === contractSources.length) 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;
     });
 }
-export { resolveEffectAdapterCrossProjectPolicy };
+export { resolveEffectServerCrossProjectPolicy };

package/dist/esm/effect-server/entry.mjs

@@ -0,0 +1,15 @@
+import node_path from "node:path";
+import "@modern-js/server-runtime-extensions/server-config";
+import { API_DIR, isProd } from "@modern-js/utils";
+import { resolveEffectEntry } from "../effect-source-loader/paths.mjs";
+function resolveEffectServerEntryFile(api) {
+    const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
+    const appDir = node_path.resolve(appDirectory || process.cwd());
+    return resolveEffectEntry({
+        appDir,
+        apiDir: node_path.resolve(appDir, apiDirectory || API_DIR),
+        effectEntry: api.getServerConfig()?.bff?.effect?.entry,
+        distDir: isProd() && distDirectory ? node_path.resolve(distDirectory) : void 0
+    }).path;
+}
+export { resolveEffectServerEntryFile };

package/dist/esm/{effect-adapter → effect-server}/error-response.mjs

@@ -1,6 +1,6 @@
 import { createSafeFailureResponse } from "@modern-js/runtime-extensions/safe-failure";
 import { logger } from "@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 : createSafeFailureResponse(error)).catch((configError)=>{
@@ -34,4 +34,4 @@ function ensureJsonContext(context) {
         }
     });
 }
-export { createEffectAdapterRuntimeErrorResponse };
+export { createEffectServerRuntimeErrorResponse };

package/dist/esm/effect-server/index.mjs

@@ -0,0 +1,151 @@
+import node_path from "node:path";
+import "@modern-js/server-runtime-extensions/server-config";
+import { dispatchEffectBffRequest, resolveEffectBffModuleHandler, useEffectContext } from "@modern-js/bff-effect/effect";
+import { resolveOperationProducer } from "@modern-js/server-runtime-extensions/bff-policy/node";
+import { createDisposableServerRuntimeHandle, registerServerRuntimeDisposer } from "@modern-js/server-runtime-extensions/runtime-lifecycle";
+import { fs, isProd, logger } from "@modern-js/utils";
+import { checkCrossProjectPolicyForRequest } from "../cross-project-policy/evaluation.mjs";
+import { loadEffectBuiltModule, loadEffectSourceModule } from "../effect-source-loader/loader.mjs";
+import { resolveEffectServerCrossProjectPolicy } from "./cross-project-policy.mjs";
+import { resolveEffectServerEntryFile } from "./entry.mjs";
+import { createEffectServerRuntimeErrorResponse } from "./error-response.mjs";
+const EFFECT_MIDDLEWARE_BEFORE = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+const effect_server = ()=>({
+        name: '@modern-js/plugin-bff-extensions/effect-server',
+        setup (api) {
+            const runtimeFramework = api.getServerContext().bffRuntimeFramework;
+            if ('effect' !== runtimeFramework) throw new Error(`Effect BFF server plugin requires Effect; received "${runtimeFramework}".`);
+            let handler = null;
+            let unregisterRuntimeDisposer;
+            let prefix = '/api';
+            let prefixes = [
+                '/api'
+            ];
+            let matchingPrefixes = [
+                '/api'
+            ];
+            let retired = false;
+            const dispose = async ()=>{
+                retired = true;
+                unregisterRuntimeDisposer?.();
+                unregisterRuntimeDisposer = void 0;
+                const previous = handler;
+                handler = null;
+                await previous?.dispose();
+            };
+            const loadHandler = async ()=>{
+                const entryFile = resolveEffectServerEntryFile(api);
+                if (!entryFile || !await fs.pathExists(entryFile)) {
+                    handler = null;
+                    return;
+                }
+                const { appDirectory } = api.getServerContext();
+                let mod;
+                try {
+                    mod = await (isProd() ? loadEffectBuiltModule(entryFile) : loadEffectSourceModule({
+                        resourcePath: entryFile,
+                        appDir: appDirectory || node_path.dirname(entryFile)
+                    }));
+                } catch (error) {
+                    logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
+                    throw error;
+                }
+                const producer = resolveOperationProducer({
+                    directories: [
+                        node_path.dirname(entryFile),
+                        appDirectory
+                    ],
+                    requestId: api.getServerConfig()?.bff?.requestId
+                });
+                const crossProjectPolicies = new Map(await Promise.all(prefixes.map(async (prefix)=>[
+                        prefix,
+                        await resolveEffectServerCrossProjectPolicy(api, prefix, mod, producer)
+                    ])));
+                const effectConfig = api.getServerConfig()?.bff?.effect;
+                const loaded = await resolveEffectBffModuleHandler(mod, {
+                    openapi: effectConfig?.openapi,
+                    dataPlatform: effectConfig?.dataPlatform,
+                    validateRequest: (request)=>{
+                        const { path: mountedPathname } = useEffectContext();
+                        const prefix = matchingPrefixes.find((item)=>'/' === item || mountedPathname === item || mountedPathname.startsWith(`${item}/`));
+                        if (!prefix) return null;
+                        const requestUrl = new URL(request.url);
+                        if ('/' !== prefix) requestUrl.pathname = '/' === requestUrl.pathname ? prefix : `${prefix}${requestUrl.pathname}`;
+                        return checkCrossProjectPolicyForRequest(new Request(requestUrl, request), crossProjectPolicies.get(prefix));
+                    },
+                    onWarning: (message)=>logger.warn(message)
+                });
+                if (!loaded) {
+                    const error = new Error(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
+                    logger.warn(error.message);
+                    throw error;
+                }
+                const candidateOwner = {};
+                if (loaded.dispose) registerServerRuntimeDisposer(candidateOwner, loaded.dispose);
+                const candidate = createDisposableServerRuntimeHandle(candidateOwner, loaded.handler);
+                if (retired) {
+                    await candidate.dispose();
+                    throw new Error('Cannot initialize a retired Effect server.');
+                }
+                handler = candidate;
+            };
+            api.onPrepare(async ()=>{
+                const { middlewares: globalMiddlewares } = api.getServerContext();
+                const configuredPrefix = api.getServerConfig()?.bff?.prefix;
+                const enableHandleWeb = api.getServerConfig()?.bff?.enableHandleWeb;
+                const configuredPrefixes = Array.isArray(configuredPrefix) ? configuredPrefix.filter(Boolean) : [
+                    configuredPrefix || '/api'
+                ];
+                prefixes = [
+                    ...new Set(configuredPrefixes.length > 0 ? configuredPrefixes : [
+                        '/api'
+                    ])
+                ];
+                matchingPrefixes = [
+                    ...prefixes
+                ].sort((left, right)=>right.length - left.length);
+                prefix = prefixes[0] || '/api';
+                const { serverBase } = api.getServerContext();
+                if (serverBase) unregisterRuntimeDisposer = registerServerRuntimeDisposer(serverBase, dispose);
+                try {
+                    await loadHandler();
+                } catch (error) {
+                    await dispose();
+                    throw error;
+                }
+                const middlewarePrefixes = enableHandleWeb ? [
+                    prefix
+                ] : matchingPrefixes;
+                const middlewares = middlewarePrefixes.map((middlewarePrefix)=>({
+                        name: 'effect-api-handler',
+                        path: enableHandleWeb ? '*' : `${middlewarePrefix}/*`,
+                        method: 'all',
+                        order: 'post',
+                        before: EFFECT_MIDDLEWARE_BEFORE,
+                        handler: async (context, next)=>{
+                            const activeHandler = handler;
+                            if (!activeHandler) {
+                                if (enableHandleWeb) return void await next();
+                                return createEffectServerRuntimeErrorResponse(api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), context);
+                            }
+                            const mountedPrefix = enableHandleWeb ? matchingPrefixes.find((item)=>'/' === item || context.req.path === item || context.req.path.startsWith(`${item}/`)) || prefix : middlewarePrefix;
+                            const response = await dispatchEffectBffRequest(activeHandler, context.req.raw, {
+                                prefix: mountedPrefix,
+                                env: context.env,
+                                path: context.req.path,
+                                method: context.req.method,
+                                onError: (error)=>createEffectServerRuntimeErrorResponse(api, error, context)
+                            });
+                            if (404 === response.status && enableHandleWeb) return void await next();
+                            return new Response(response.body, response);
+                        }
+                    }));
+                globalMiddlewares.push(...middlewares);
+            });
+        }
+    });
+export default effect_server;

package/dist/esm/{client-generator → effect-source-loader}/built-entry.mjs

@@ -1,11 +1,10 @@
 import { fs, upath } from "@modern-js/utils";
-import { resolveEffectEntryFile } from "./paths.mjs";
-const BUILT_ENTRY_EXT = /\.(?:[cm]?ts|tsx|jsx)$/u;
+import { emittedEffectEntry, relativeEffectAppPath, resolveEffectEntryFile } from "./paths.mjs";
 function resolveBuiltEffectEntry(appDirectory, distDirectory, sourceEntry) {
     if (void 0 === sourceEntry || 0 === sourceEntry.length) return;
-    const relativeEntry = upath.relative(appDirectory, sourceEntry);
-    if ('..' === relativeEntry || relativeEntry.startsWith(`..${upath.sep}`)) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
-    const builtEntry = upath.resolve(distDirectory, relativeEntry).replace(BUILT_ENTRY_EXT, '.js');
+    const relativeEntry = relativeEffectAppPath(appDirectory, sourceEntry);
+    if (void 0 === relativeEntry) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
+    const builtEntry = emittedEffectEntry(upath.resolve(distDirectory, relativeEntry));
     return fs.existsSync(builtEntry) ? builtEntry : void 0;
 }
 async function bundleBuiltEffectEntryForNode(options) {
@@ -17,7 +16,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 ?? upath.resolve(apiDir, 'index')}`);
-    const { bundleEffectEntryForNode } = await import("../effect-source-loader/loader.mjs");
+    const { bundleEffectEntryForNode } = await import("./loader.mjs");
     return bundleEffectEntryForNode({
         appDir,
         entryPath: builtEntry,
@@ -31,7 +30,7 @@ function resolveEffectEntryPaths(options) {
         apiDir,
         effectEntry
     });
-    const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? upath.relative(appDir, sourceEffectEntry).replace(BUILT_ENTRY_EXT, '.js') : '';
+    const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? emittedEffectEntry(upath.relative(appDir, sourceEffectEntry)) : '';
     return {
         sourceEffectEntry,
         relativeEffectEntry