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

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

@@ -30,6 +30,16 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE: ()=>EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE,
+    adoptEffectBffShareScope: ()=>adoptEffectBffShareScope,
+    classifyEffectBffEntryModule: ()=>classifyEffectBffEntryModule,
+    isValidatorAwareHandlerFactory: ()=>isValidatorAwareHandlerFactory,
+    registerValidatorAwareHandlerFactory: ()=>registerValidatorAwareHandlerFactory,
+    strictEffectApproachMessage: ()=>strictEffectApproachMessage
+});
+const context_namespaceObject = require("@modern-js/bff-effect/context");
+const EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE = '@modern-js/bff-effect/handler-factory-registry';
 function createLocalValidatorAwareHandlerFactoryRegistry() {
     const factories = new WeakSet();
     return {
@@ -53,12 +63,33 @@ function loadNodeValidatorAwareHandlerFactoryRegistry() {
         throw error;
     }
 }
-const validatorAwareHandlerFactoryRegistry = loadNodeValidatorAwareHandlerFactoryRegistry();
+let validatorAwareHandlerFactoryRegistry;
+function handlerFactoryRegistry() {
+    validatorAwareHandlerFactoryRegistry ??= loadNodeValidatorAwareHandlerFactoryRegistry();
+    return validatorAwareHandlerFactoryRegistry;
+}
+const adoptShared = (shareScope, name, adopt)=>{
+    const versions = 'object' == typeof shareScope && null !== shareScope ? shareScope[name] : void 0;
+    const shared = void 0 === versions ? void 0 : Object.values(versions)[0];
+    if ('function' != typeof shared?.get) return Promise.resolve();
+    return Promise.resolve(shared.get()).then((factory)=>adopt('function' == typeof factory ? factory() : void 0));
+};
+function adoptEffectBffShareScope(shareScope) {
+    return Promise.all([
+        adoptShared(shareScope, EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE, (registry)=>adoptHandlerFactoryRegistry(registry)),
+        adoptShared(shareScope, context_namespaceObject.EFFECT_BFF_CONTEXT_STORAGE_SHARE, context_namespaceObject.adoptEffectContextStorage)
+    ]).then(()=>void 0);
+}
+function adoptHandlerFactoryRegistry(registry) {
+    if ('function' != typeof registry?.register || 'function' != typeof registry.is) throw new Error(`[BFF][Effect] Share ${EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE} must provide a handler factory registry.`);
+    if (void 0 !== validatorAwareHandlerFactoryRegistry && validatorAwareHandlerFactoryRegistry !== registry) throw new Error('[BFF][Effect] A backend federation container received the host handler factory registry after an Effect API already used its own. Evaluate exposes only after container init().');
+    validatorAwareHandlerFactoryRegistry = registry;
+}
 function registerValidatorAwareHandlerFactory(factory) {
-    return validatorAwareHandlerFactoryRegistry.register(factory);
+    return handlerFactoryRegistry().register(factory);
 }
 function isValidatorAwareHandlerFactory(factory) {
-    return validatorAwareHandlerFactoryRegistry.is(factory);
+    return handlerFactoryRegistry().is(factory);
 }
 const strictEffectApproachMessage = '[BFF][Effect] strictEffectApproach is enforced: Effect API entries export defineEffectBff(...) or { api, layer } HttpApi module. Raw handler exports, default request handlers, unbranded custom createHandler factories not valid Effect API entries.';
 function isEffectEntryRecord(value) {
@@ -77,13 +108,13 @@ function classifyEffectBffEntryModule(value, predicates) {
     if (predicates.isRequestHandler(module.handler)) return createEntryShapeFacts(module, predicates, '`handler` export');
     return createEntryShapeFacts(module, predicates);
 }
-function createEntryShapeFacts(module, predicates, legacyShape) {
+function createEntryShapeFacts(module, predicates, unsupportedShape) {
     const createHandler = 'function' == typeof module.createHandler ? module.createHandler : void 0;
     const api = predicates.isHttpApi(module.api) ? module.api : void 0;
     const hasRuntimeLayer = void 0 !== module.layer;
     return {
         module,
-        legacyShape,
+        unsupportedShape,
         createHandler,
         createHandlerValidatorAware: void 0 !== createHandler && predicates.isValidatorAwareHandlerFactory(createHandler),
         api,
@@ -91,18 +122,15 @@ function createEntryShapeFacts(module, predicates, legacyShape) {
         hasRuntimeLayer
     };
 }
-__webpack_require__.d(__webpack_exports__, {
-    classifyEffectBffEntryModule: ()=>classifyEffectBffEntryModule,
-    isValidatorAwareHandlerFactory: ()=>isValidatorAwareHandlerFactory,
-    registerValidatorAwareHandlerFactory: ()=>registerValidatorAwareHandlerFactory
-}, {
-    strictEffectApproachMessage: strictEffectApproachMessage
-});
+exports.EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE = __webpack_exports__.EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE;
+exports.adoptEffectBffShareScope = __webpack_exports__.adoptEffectBffShareScope;
 exports.classifyEffectBffEntryModule = __webpack_exports__.classifyEffectBffEntryModule;
 exports.isValidatorAwareHandlerFactory = __webpack_exports__.isValidatorAwareHandlerFactory;
 exports.registerValidatorAwareHandlerFactory = __webpack_exports__.registerValidatorAwareHandlerFactory;
 exports.strictEffectApproachMessage = __webpack_exports__.strictEffectApproachMessage;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE",
+    "adoptEffectBffShareScope",
     "classifyEffectBffEntryModule",
     "isValidatorAwareHandlerFactory",
     "registerValidatorAwareHandlerFactory",

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

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createEffectBffEdgeDispatcherFactory: ()=>createEffectBffEdgeDispatcherFactory
+});
+const external_edge_dispatcher_js_namespaceObject = require("./edge-dispatcher.js");
+function createEffectBffEdgeDispatcherFactory(module, generatedOperationContracts) {
+    return (options)=>{
+        const policy = options?.crossProjectPolicy;
+        const crossProjectPolicy = null == policy || null === policy.expectedOperationContracts || 'object' != typeof policy.expectedOperationContracts || Array.isArray(policy.expectedOperationContracts) ? policy : {
+            ...policy,
+            expectedOperationContracts: {
+                ...policy.expectedOperationContracts,
+                ...generatedOperationContracts
+            }
+        };
+        return (0, external_edge_dispatcher_js_namespaceObject.createEffectBffEdgeDispatcher)({
+            ...options,
+            crossProjectPolicy,
+            module
+        });
+    };
+}
+exports.createEffectBffEdgeDispatcherFactory = __webpack_exports__.createEffectBffEdgeDispatcherFactory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectBffEdgeDispatcherFactory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/handler/batch-handler.js

@@ -30,7 +30,9 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createDataPlatformBatchRequestHandler: ()=>createDataPlatformBatchRequestHandler
 });
+const Effect_namespaceObject = require("effect/Effect");
 const index_js_namespaceObject = require("../../data-platform/index.js");
+const options_js_namespaceObject = require("../../data-platform/batch/options.js");
 const protocol_js_namespaceObject = require("../../data-platform/batch/protocol.js");
 const external_batch_js_namespaceObject = require("./batch.js");
 const external_routing_js_namespaceObject = require("./routing.js");
@@ -122,11 +124,9 @@ function createDataPlatformBatchRequestHandler(options) {
     const dataPlatformBatchOptions = options.dataPlatform?.batch;
     const batchEnabled = dataPlatformBatchOptions?.enabled !== false;
     const batchPath = (0, external_batch_js_namespaceObject.normalizeBatchPath)(dataPlatformBatchOptions?.endpoint);
-    const batchMaxSize = Math.max(1, dataPlatformBatchOptions?.maxBatchSize ?? 16);
-    const batchMaxBytes = Math.max(1024, dataPlatformBatchOptions?.maxBatchBytes ?? 65536);
+    const { maxBatchSize: batchMaxSize, maxBatchBytes: batchMaxBytes, allowedMethods: batchAllowedMethods } = (0, options_js_namespaceObject.normalizeBatchLimits)(dataPlatformBatchOptions);
     const batchConcurrency = Math.max(1, dataPlatformBatchOptions?.maxConcurrency ?? 4);
     const batchItemTimeoutMs = Math.max(0, dataPlatformBatchOptions?.requestTimeoutMs ?? 10000);
-    const batchAllowedMethods = (0, external_batch_js_namespaceObject.normalizeBatchAllowedMethods)(dataPlatformBatchOptions?.allowedMethods);
     const envelopeHeader = options.dataPlatform?.envelopeHeader || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
     const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
     const handle = async (request, context)=>{
@@ -216,25 +216,25 @@ function createDataPlatformBatchRequestHandler(options) {
                 return (0, protocol_js_namespaceObject.toBatchResponseItem)(itemId, itemResponse, 'HEAD' === itemMethod);
             } catch (error) {
                 if (error instanceof external_batch_js_namespaceObject.BatchItemTimeoutError) {
-                    console.error({
+                    Effect_namespaceObject.runSync(Effect_namespaceObject.logError({
                         event: 'bff.batch.item.timeout',
                         batchId: payload.batchId,
                         itemId,
                         method: itemMethod,
                         path: itemPathname,
                         errorName: error.name
-                    });
+                    }));
                     return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 504, 'Batch item request timed out');
                 }
                 if (error instanceof Response) return (0, protocol_js_namespaceObject.toBatchResponseItem)(itemId, error, 'HEAD' === itemMethod);
-                console.error({
+                Effect_namespaceObject.runSync(Effect_namespaceObject.logError({
                     event: 'bff.batch.item.failure',
                     batchId: payload.batchId,
                     itemId,
                     method: itemMethod,
                     path: itemPathname,
                     errorName: error instanceof Error ? error.name : 'UnknownError'
-                });
+                }));
                 return (0, external_batch_js_namespaceObject.toBatchItemError)(itemId, 500, 'Internal Server Error');
             } finally{
                 request.signal.removeEventListener('abort', abortFromBatchRequest);

package/dist/cjs/effect/handler/batch.js

@@ -32,13 +32,13 @@ __webpack_require__.d(__webpack_exports__, {
     createBatchValidationResponse: ()=>createBatchValidationResponse,
     isBatchRequestPayload: ()=>isBatchRequestPayload,
     mapWithConcurrency: ()=>mapWithConcurrency,
-    normalizeBatchAllowedMethods: ()=>normalizeBatchAllowedMethods,
     normalizeBatchPath: ()=>normalizeBatchPath,
     prepareJsonRequestBody: ()=>prepareJsonRequestBody,
     promiseWithTimeout: ()=>promiseWithTimeout,
     toBatchItemError: ()=>toBatchItemError,
     toHeaderRecord: ()=>external_headers_js_namespaceObject.toHeaderRecord
 });
+const Data_namespaceObject = require("effect/Data");
 const index_js_namespaceObject = require("../../data-platform/index.js");
 const protocol_js_namespaceObject = require("../../data-platform/batch/protocol.js");
 const external_headers_js_namespaceObject = require("../../headers.js");
@@ -47,12 +47,6 @@ function normalizeBatchPath(pathname) {
     if (!pathname.startsWith('/')) return `/${pathname}`;
     return pathname;
 }
-function normalizeBatchAllowedMethods(allowedMethods) {
-    const source = Array.isArray(allowedMethods) && allowedMethods.length > 0 ? allowedMethods : [
-        'GET'
-    ];
-    return new Set(source.map((method)=>method.toUpperCase()));
-}
 function isBatchRequestPayload(value) {
     return (0, index_js_namespaceObject.isPlainObject)(value) && 2 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.sentAt && Array.isArray(value.items);
 }
@@ -106,7 +100,13 @@ function toBatchItemError(id, status, message) {
         }))
     };
 }
-class BatchItemTimeoutError extends Error {
+class BatchItemTimeoutError extends Data_namespaceObject.TaggedError('BatchItemTimeoutError') {
+    constructor(message){
+        super({
+            message
+        });
+        this.name = 'Error';
+    }
 }
 function promiseWithTimeout(effect, timeoutMs, onTimeout) {
     if (timeoutMs <= 0) return effect;
@@ -147,7 +147,6 @@ exports.BatchItemTimeoutError = __webpack_exports__.BatchItemTimeoutError;
 exports.createBatchValidationResponse = __webpack_exports__.createBatchValidationResponse;
 exports.isBatchRequestPayload = __webpack_exports__.isBatchRequestPayload;
 exports.mapWithConcurrency = __webpack_exports__.mapWithConcurrency;
-exports.normalizeBatchAllowedMethods = __webpack_exports__.normalizeBatchAllowedMethods;
 exports.normalizeBatchPath = __webpack_exports__.normalizeBatchPath;
 exports.prepareJsonRequestBody = __webpack_exports__.prepareJsonRequestBody;
 exports.promiseWithTimeout = __webpack_exports__.promiseWithTimeout;
@@ -158,7 +157,6 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createBatchValidationResponse",
     "isBatchRequestPayload",
     "mapWithConcurrency",
-    "normalizeBatchAllowedMethods",
     "normalizeBatchPath",
     "prepareJsonRequestBody",
     "promiseWithTimeout",

package/dist/cjs/effect/handler/definition.js

@@ -53,30 +53,10 @@ function defineEffectBff(definition) {
             validateRequest: options?.validateRequest
         });
     });
-    const client = createLoaderMaterializedClientPlaceholder();
     return {
         ...definition,
-        createHandler,
-        client
-    };
-}
-const LOADER_CLIENT_IGNORED_KEYS = new Set([
-    'then',
-    'catch',
-    'finally',
-    'toJSON',
-    '$$typeof'
-]);
-function createLoaderMaterializedClientPlaceholder() {
-    const explain = (property)=>{
-        throw new Error(`[BFF][Effect] client.${String(property)} is not available here: the typed client only exists when the API entry is imported through the "@api/index" transformed path (the BFF loader replaces it with generated client code). On the server, use HttpApiClient or call the Effect layer directly.`);
+        createHandler
     };
-    return new Proxy(Object.create(null), {
-        get (_target, property) {
-            if ('symbol' == typeof property || LOADER_CLIENT_IGNORED_KEYS.has(property)) return;
-            return explain(property);
-        }
-    });
 }
 function defineEffectRpcBff(definition) {
     const createHandler = (options)=>(0, external_rpc_js_namespaceObject.createRpcApiHandler)({

package/dist/cjs/effect/index.js

@@ -1,8 +1,5 @@
 "use strict";
 var __webpack_modules__ = {
-    "./context" (module) {
-        module.exports = require("./context.js");
-    },
     "./edge" (module) {
         module.exports = require("./edge.js");
     },
@@ -17,6 +14,9 @@ var __webpack_modules__ = {
     },
     "@effect/opentelemetry" (module) {
         module.exports = require("@effect/opentelemetry");
+    },
+    "@modern-js/bff-effect/context" (module) {
+        module.exports = require("@modern-js/bff-effect/context");
     }
 };
 var __webpack_module_cache__ = {};
@@ -67,7 +67,7 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     var _effect_opentelemetry__rspack_import_0 = __webpack_require__("@effect/opentelemetry");
-    var _context__rspack_import_1 = __webpack_require__("./context");
+    var _modern_js_bff_effect_context__rspack_import_1 = __webpack_require__("@modern-js/bff-effect/context");
     var _edge__rspack_import_2 = __webpack_require__("./edge");
     var _endpoint_contracts__rspack_import_3 = __webpack_require__("./endpoint-contracts");
     var __rspack_reexport = {};
@@ -104,12 +104,12 @@ var __webpack_exports__ = {};
         OpenTelemetry: ()=>_effect_opentelemetry__rspack_import_0,
         createEffectBffEdgeHandler: ()=>_edge__rspack_import_2.createEffectBffEdgeHandler,
         createEffectBffTestHandler: ()=>_edge__rspack_import_2.createEffectBffTestHandler,
-        createEffectOperationContext: ()=>_context__rspack_import_1.createEffectOperationContext,
+        createEffectOperationContext: ()=>_modern_js_bff_effect_context__rspack_import_1.createEffectOperationContext,
         dispatchEffectBffRequest: ()=>_edge__rspack_import_2.dispatchEffectBffRequest,
         resolveEffectBffModuleHandler: ()=>_module__rspack_import_5.resolveEffectBffModuleHandler,
-        runWithEffectContext: ()=>_context__rspack_import_1.runWithEffectContext,
-        useEffectContext: ()=>_context__rspack_import_1.useEffectContext,
-        useOperationContext: ()=>_context__rspack_import_1.useOperationContext
+        runWithEffectContext: ()=>_modern_js_bff_effect_context__rspack_import_1.runWithEffectContext,
+        useEffectContext: ()=>_modern_js_bff_effect_context__rspack_import_1.useEffectContext,
+        useOperationContext: ()=>_modern_js_bff_effect_context__rspack_import_1.useOperationContext
     });
 })();
 exports.OpenTelemetry = __webpack_exports__.OpenTelemetry;

package/dist/cjs/effect/module.js

@@ -43,7 +43,7 @@ function shareDispose(dispose) {
         return disposePromise;
     };
 }
-function rejectLegacyEffectModuleShape(options, shape) {
+function rejectUnsupportedEffectModuleShape(options, shape) {
     options.onWarning?.(`${external_entry_shape_js_namespaceObject.strictEffectApproachMessage} Rejected ${shape}.`);
     return true;
 }
@@ -71,8 +71,12 @@ function classifyEffectBffRuntimeEntryShape(module) {
 }
 function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
     if (!facts) return null;
-    if (facts.legacyShape) {
-        if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) return null;
+    if (facts.unsupportedShape) {
+        if (rejectUnsupportedEffectModuleShape(options, facts.unsupportedShape)) return null;
+    }
+    if (void 0 !== facts.module.rpc && !facts.createHandlerValidatorAware) {
+        rejectUnsupportedEffectModuleShape(options, 'unbranded RPC runtime');
+        return null;
     }
     if ('function' == typeof facts.createHandler) {
         if (facts.createHandlerValidatorAware) {
@@ -85,7 +89,7 @@ function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
             return createLoadedHandler(webHandler);
         }
         if (void 0 === facts.api || !facts.hasRuntimeLayer) {
-            rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export');
+            rejectUnsupportedEffectModuleShape(options, 'unbranded `createHandler` export');
             return null;
         }
         options.onWarning?.(`${external_entry_shape_js_namespaceObject.strictEffectApproachMessage} Ignored unbranded \`createHandler\` export and rebuilt the handler from its { api, layer } exports.`);

package/dist/cjs/effect/operation-context.js

@@ -28,11 +28,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createEffectOperationContext: ()=>createEffectOperationContext,
-    kEffectContextStorage: ()=>kEffectContextStorage
+    createEffectOperationContext: ()=>createEffectOperationContext
 });
-const create_request_namespaceObject = require("@modern-js/create-request");
-const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
+const request_context_namespaceObject = require("@modern-js/runtime-extensions/request-context");
 const readHeader = (headers, header)=>{
     const value = headers.get(header);
     return value && value.length > 0 ? value : void 0;
@@ -42,7 +40,7 @@ const copyStringField = (target, details, key)=>{
     if ('string' == typeof value && value.length > 0) target[key] = value;
 };
 const readOperationContextDetails = (request)=>{
-    const rawDetails = readHeader(request.headers, create_request_namespaceObject.BFF_OPERATION_CONTEXT_DETAIL_HEADER);
+    const rawDetails = readHeader(request.headers, request_context_namespaceObject.BFF_OPERATION_CONTEXT_DETAIL_HEADER);
     if (!rawDetails) return {};
     try {
         const parsed = JSON.parse(rawDetails);
@@ -70,16 +68,16 @@ const createEffectOperationContext = ({ request, path, method })=>{
     delete operationDetails.traceId;
     delete operationDetails.spanId;
     const servicePath = new URL(request.url).pathname;
-    const headerTraceparent = readHeader(request.headers, create_request_namespaceObject.BFF_TRACEPARENT_HEADER);
-    const headerTraceContext = (0, create_request_namespaceObject.parseTraceparent)(headerTraceparent);
-    const detailTraceContext = (0, create_request_namespaceObject.parseTraceparent)(details.traceparent);
+    const headerTraceparent = readHeader(request.headers, request_context_namespaceObject.BFF_TRACEPARENT_HEADER);
+    const headerTraceContext = (0, request_context_namespaceObject.parseTraceparent)(headerTraceparent);
+    const detailTraceContext = (0, request_context_namespaceObject.parseTraceparent)(details.traceparent);
     const traceparent = headerTraceContext ? headerTraceparent : detailTraceContext ? details.traceparent : void 0;
     const parsedTraceparent = headerTraceContext || detailTraceContext || (details.traceId && details.spanId ? {
         traceId: details.traceId,
         spanId: details.spanId
     } : void 0);
-    const locale = readHeader(request.headers, create_request_namespaceObject.BFF_LOCALE_HEADER);
-    const headerOperationId = readHeader(request.headers, create_request_namespaceObject.BFF_OPERATION_CONTEXT_HEADER);
+    const locale = readHeader(request.headers, request_context_namespaceObject.BFF_LOCALE_HEADER);
+    const headerOperationId = readHeader(request.headers, request_context_namespaceObject.BFF_OPERATION_CONTEXT_HEADER);
     return {
         ...operationDetails,
         ...headerOperationId || details.operationId ? {
@@ -87,7 +85,7 @@ const createEffectOperationContext = ({ request, path, method })=>{
         } : {},
         routePath: servicePath,
         method: (method || request.method || 'GET').toUpperCase(),
-        source: 'effect-adapter',
+        source: 'effect-server',
         ...path && path !== servicePath ? {
             attributes: {
                 mountedPath: path
@@ -106,10 +104,8 @@ const createEffectOperationContext = ({ request, path, method })=>{
     };
 };
 exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
-exports.kEffectContextStorage = __webpack_exports__.kEffectContextStorage;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createEffectOperationContext",
-    "kEffectContextStorage"
+    "createEffectOperationContext"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/effect/rpcSerialization.js

@@ -39,8 +39,6 @@ function getRpcSerializationLayer(serialization) {
             return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
         case 'ndJsonRpc':
             return rpc_namespaceObject.RpcSerialization.layerNdJsonRpc();
-        case 'msgPack':
-            return rpc_namespaceObject.RpcSerialization.layerMsgPack;
         default:
             return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
     }

package/dist/cjs/effect-client/cross-project.js

@@ -0,0 +1,89 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    withCrossProjectPolicy: ()=>withCrossProjectPolicy
+});
+const bff_policy_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy");
+const Effect_namespaceObject = require("effect/Effect");
+const Schema_namespaceObject = require("effect/Schema");
+const http_namespaceObject = require("effect/unstable/http");
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const encodeJson = Schema_namespaceObject.encodeSync(Schema_namespaceObject.fromJsonString(Schema_namespaceObject.Unknown));
+function withCrossProjectPolicy(api, options, client) {
+    const contracts = {};
+    const prefix = options.prefix.replace(/\/$/, '');
+    httpapi_namespaceObject.HttpApi.reflect(api, {
+        onGroup: ()=>{},
+        onEndpoint: ({ endpoint })=>{
+            const routePath = `${prefix}${'/' === endpoint.path ? '' : endpoint.path}` || '/';
+            const name = endpoint.identifier;
+            contracts[`${endpoint.method}:${routePath}`] = {
+                operationId: `${options.requestId}:${name}`,
+                name,
+                method: endpoint.method,
+                routePath
+            };
+        }
+    });
+    return client.pipe(http_namespaceObject.HttpClient.mapRequestEffect((request)=>{
+        const observed = (0, bff_policy_namespaceObject.resolveCrossProjectRequestObservation)({
+            method: request.method,
+            pathname: new URL(request.url, 'http://effect.invalid').pathname
+        }, {
+            expectedOperationContracts: contracts
+        });
+        const contract = observed && contracts[`${observed.method}:${observed.routePath}`];
+        if (void 0 === contract) return Effect_namespaceObject.die(new Error('[BFF][Effect] Request has no matching shared operation contract.'));
+        return Effect_namespaceObject.gen(function*() {
+            const schemaHash = yield* Effect_namespaceObject.promise(()=>(0, bff_policy_namespaceObject.digestOperationContract)({
+                    httpMethod: contract.method,
+                    name: contract.name,
+                    routePath: contract.routePath
+                }, options.requestId));
+            return request.pipe(http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_ENVELOPE_HEADER, encodeJson({
+                requestId: options.requestId
+            })), http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_OPERATION_CONTEXT_HEADER, contract.operationId), http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_OPERATION_CONTEXT_DETAIL_HEADER, encodeJson({
+                requestId: options.requestId,
+                operationId: contract.operationId,
+                method: contract.method,
+                routePath: contract.routePath,
+                schemaHash,
+                operationVersion: options.operationVersion
+            })));
+        });
+    }));
+}
+exports.withCrossProjectPolicy = __webpack_exports__.withCrossProjectPolicy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "withCrossProjectPolicy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -50,7 +50,7 @@ __webpack_require__.d(__webpack_exports__, {
     runEffectView: ()=>runEffectView,
     view: ()=>view
 });
-const create_request_namespaceObject = require("@modern-js/create-request");
+const request_context_namespaceObject = require("@modern-js/runtime-extensions/request-context");
 const Data_namespaceObject = require("effect/Data");
 const Effect_namespaceObject = require("effect/Effect");
 const Exit_namespaceObject = require("effect/Exit");
@@ -61,6 +61,7 @@ const http_namespaceObject = require("effect/unstable/http");
 const httpapi_namespaceObject = require("effect/unstable/httpapi");
 const rpc_namespaceObject = require("effect/unstable/rpc");
 const rpcSerialization_js_namespaceObject = require("../effect/rpcSerialization.js");
+const external_cross_project_js_namespaceObject = require("./cross-project.js");
 const Schema_namespaceObject = require("effect/Schema");
 const HttpClientError_namespaceObject = require("effect/unstable/http/HttpClientError");
 class EffectRpcClientError extends Data_namespaceObject.TaggedError('EffectRpcClientError') {
@@ -91,14 +92,15 @@ function runEffectView(request, selection) {
     });
 }
 function makeEffectHttpApiClient(api, options) {
-    const requestContextHeaders = (0, create_request_namespaceObject.createRequestContextHeaders)(options?.requestContext);
+    const requestContextHeaders = (0, request_context_namespaceObject.createRequestContextHeaders)(options?.requestContext);
     const transformClient = (client)=>{
         const contextClient = 0 === Object.keys(requestContextHeaders).length ? client : client.pipe(http_namespaceObject.HttpClient.mapRequest((request)=>{
             let nextRequest = request;
             for (const [header, value] of Object.entries(requestContextHeaders))if (void 0 === nextRequest.headers[header.toLowerCase()]) nextRequest = http_namespaceObject.HttpClientRequest.setHeader(nextRequest, header, value);
             return nextRequest;
         }));
-        return 'function' == typeof options?.transformClient ? options.transformClient(contextClient) : contextClient;
+        const policyClient = options?.crossProject !== void 0 ? (0, external_cross_project_js_namespaceObject.withCrossProjectPolicy)(api, options.crossProject, contextClient) : contextClient;
+        return 'function' == typeof options?.transformClient ? options.transformClient(policyClient) : policyClient;
     };
     return httpapi_namespaceObject.HttpApiClient.make(api, {
         baseUrl: options?.baseUrl,