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

package/dist/cjs/assembly.js

@@ -30,11 +30,11 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     assembleEffectBffRuntime: ()=>assembleEffectBffRuntime
 });
+const http_api_namespaceObject = require("effect/http-api");
 const Layer_namespaceObject = require("effect/Layer");
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
 const definition_js_namespaceObject = require("./effect/handler/definition.js");
 const assembleEffectBffRuntime = ({ api, handlers, transport })=>{
-    const apiLayer = httpapi_namespaceObject.HttpApiBuilder.layer(api).pipe(Layer_namespaceObject.provide(handlers));
+    const apiLayer = http_api_namespaceObject.HttpApiBuilder.layer(api).pipe(Layer_namespaceObject.provide(handlers));
     const layer = void 0 === transport ? apiLayer : apiLayer.pipe(Layer_namespaceObject.merge(transport));
     return (0, definition_js_namespaceObject.defineEffectBff)({
         api,

package/dist/cjs/data-platform/batch/options.js

@@ -0,0 +1,48 @@
+"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__);
+function normalizeBatchLimits(options = {}) {
+    return {
+        maxBatchSize: Math.max(1, options.maxBatchSize ?? 16),
+        maxBatchBytes: Math.max(1024, options.maxBatchBytes ?? 65536),
+        allowedMethods: new Set((void 0 !== options.allowedMethods && options.allowedMethods.length > 0 ? options.allowedMethods : [
+            'GET'
+        ]).map((method)=>method.toUpperCase()))
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    normalizeBatchLimits: ()=>normalizeBatchLimits
+});
+exports.normalizeBatchLimits = __webpack_exports__.normalizeBatchLimits;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeBatchLimits"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data-platform/batch/queue.js

@@ -33,6 +33,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_codec_js_namespaceObject = require("../codec.js");
 const external_types_js_namespaceObject = require("../types.js");
+const external_options_js_namespaceObject = require("./options.js");
 const external_protocol_js_namespaceObject = require("./protocol.js");
 const external_request_js_namespaceObject = require("./request.js");
 const external_response_js_namespaceObject = require("./response.js");
@@ -111,7 +112,6 @@ class BatchBucketRegistry {
         if (existing) return existing;
         const next = {
             items: [],
-            bytes: 0,
             batchId: (0, external_request_js_namespaceObject.createBatchId)(),
             sentAt: Date.now(),
             timer: null,
@@ -130,12 +130,8 @@ class BatchBucketRegistry {
 }
 function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
     const flushIntervalMs = Math.max(0, options.flushIntervalMs ?? 8);
-    const maxBatchSize = Math.max(1, options.maxBatchSize ?? 16);
-    const maxBatchBytes = Math.max(1024, options.maxBatchBytes ?? 65536);
+    const { maxBatchSize, maxBatchBytes, allowedMethods } = (0, external_options_js_namespaceObject.normalizeBatchLimits)(options);
     const requestTimeoutMs = options.requestTimeoutMs;
-    const allowedMethods = new Set((options.allowedMethods && options.allowedMethods.length > 0 ? options.allowedMethods : [
-        'GET'
-    ]).map((method)=>method.toUpperCase()));
     const onEvent = options.onEvent;
     const buckets = bucketRegistry ?? new BatchBucketRegistry();
     const pendingByKey = new Map();
@@ -168,7 +164,6 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const index = bucket.items.indexOf(request);
         if (-1 === index) return;
         bucket.items.splice(index, 1);
-        bucket.bytes = measurePayload(bucket, bucket.items);
         if (0 === bucket.items.length && bucket.timer) {
             clearTimeout(bucket.timer);
             bucket.timer = null;
@@ -210,7 +205,11 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         if (!SAFE_REPLAY_METHODS.has(request.item.method)) throw new Error(`Batch result is unknown for ${request.item.method}; automatic replay is disabled (${reason}).`);
         return runSingle(request);
     };
-    const settleAmbiguousBatchRequests = (items, reason)=>settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+    const finishFlush = (bucketKey, bucket)=>{
+        bucket.flushing = false;
+        if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
+        buckets.releaseIfIdle(bucketKey, bucket);
+    };
     const flushBucket = async (bucketKey)=>{
         const bucket = buckets.get(bucketKey);
         if (!bucket || bucket.flushing) return;
@@ -227,7 +226,6 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             sentAt: bucket.sentAt
         };
         bucket.items = [];
-        bucket.bytes = 0;
         rotatePayloadIdentity(bucket);
         const firstItem = items[0];
         if (!firstItem) {
@@ -243,14 +241,25 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                 size: items.length,
                 reason: disabledEndpoints.has(endpoint) ? 'batch-disabled' : void 0
             });
-            await settleRequests(items, runSingle);
-            bucket.flushing = false;
-            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
-            buckets.releaseIfIdle(bucketKey, bucket);
+            try {
+                await settleRequests(items, runSingle);
+            } finally{
+                finishFlush(bucketKey, bucket);
+            }
             return;
         }
         const payload = createPayload(payloadIdentity, items);
         const batchId = payload.batchId;
+        const settleAmbiguousBatchRequests = (reason)=>{
+            (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                type: 'fallback',
+                endpoint,
+                batchId,
+                size: items.length,
+                reason
+            });
+            return settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+        };
         (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
             type: 'flush',
             endpoint,
@@ -301,42 +310,13 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                         batchId,
                         reason: `batch-endpoint-unavailable-${String(response.status)}`
                     });
-                } else (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: `batch-response-${String(response.status)}`
-                });
-                await settleAmbiguousBatchRequests(items, `batch-response-${String(response.status)}`);
-                bucket.flushing = false;
+                    await settleRequests(items, (request)=>runAfterAmbiguousBatch(request, `batch-response-${String(response.status)}`));
+                } else await settleAmbiguousBatchRequests(`batch-response-${String(response.status)}`);
                 return;
             }
             const result = await runWithSignal(controller.signal, async ()=>response.json());
-            if (!(0, external_response_js_namespaceObject.isBatchResponsePayload)(result)) {
-                (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: 'invalid-batch-response'
-                });
-                await settleAmbiguousBatchRequests(items, 'invalid-batch-response');
-                bucket.flushing = false;
-                return;
-            }
-            if (result.batchId !== batchId) {
-                (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: 'mismatched-batch-id'
-                });
-                await settleAmbiguousBatchRequests(items, 'mismatched-batch-id');
-                bucket.flushing = false;
-                return;
-            }
+            if (!(0, external_response_js_namespaceObject.isBatchResponsePayload)(result)) return void await settleAmbiguousBatchRequests('invalid-batch-response');
+            if (result.batchId !== batchId) return void await settleAmbiguousBatchRequests('mismatched-batch-id');
             const itemMap = new Map();
             for (const item of result.items)itemMap.set(item.id, item);
             await settleRequests(items, async (request)=>{
@@ -360,19 +340,10 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                 });
                 return;
             }
-            (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
-                type: 'fallback',
-                endpoint,
-                batchId,
-                size: items.length,
-                reason: 'batch-transport-error'
-            });
-            await settleAmbiguousBatchRequests(items, 'batch-transport-error');
+            await settleAmbiguousBatchRequests('batch-transport-error');
         } finally{
             for (const item of items)item.abortBatchIfUnused = void 0;
-            bucket.flushing = false;
-            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
-            buckets.releaseIfIdle(bucketKey, bucket);
+            finishFlush(bucketKey, bucket);
         }
     };
     const pendingReadPromises = new Map();
@@ -396,7 +367,20 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const sourceSignal = initDefinesSignal ? initSignal ?? void 0 : sourceRequest?.signal;
         const requestUrl = (0, external_url_js_namespaceObject.toAbsoluteUrl)(input);
         const endpoint = (0, external_url_js_namespaceObject.normalizeBatchEndpoint)(requestUrl, options.endpoint).toString();
+        const itemHeaders = {
+            ...headers
+        };
+        delete itemHeaders.authorization;
+        delete itemHeaders.cookie;
         return {
+            itemHeaders,
+            itemPath: `${requestUrl.pathname}${requestUrl.search}`,
+            bucketKey: (0, external_codec_js_namespaceObject.stableStringify)({
+                endpoint,
+                authorization: headers.authorization ?? null,
+                cookie: headers.cookie ?? null,
+                credentials
+            }),
             requestUrl,
             endpoint,
             method,
@@ -429,22 +413,11 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             batchEndpoint: request.endpoint,
             requestUrl: request.requestUrl
         })) return;
-        const itemHeaders = {
-            ...request.headers
-        };
-        delete itemHeaders.authorization;
-        delete itemHeaders.cookie;
-        const bucketKey = (0, external_codec_js_namespaceObject.stableStringify)({
-            endpoint: request.endpoint,
-            authorization: request.headers.authorization ?? null,
-            cookie: request.headers.cookie ?? null,
-            credentials: request.credentials
-        });
         return (0, external_codec_js_namespaceObject.stableStringify)({
-            bucketKey,
-            path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+            bucketKey: request.bucketKey,
+            path: request.itemPath,
             method: request.method,
-            headers: itemHeaders,
+            headers: request.itemHeaders,
             body: null
         });
     };
@@ -462,26 +435,19 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const itemId = `${Date.now().toString(36)}_${nextItemId.toString(36)}_${Math.random().toString(16).slice(2, 8)}`;
         nextItemId += 1;
         const itemHeaders = {
-            ...request.headers
+            ...request.itemHeaders
         };
-        delete itemHeaders.authorization;
-        delete itemHeaders.cookie;
         if (preparedBody.body && preparedBody.inferredContentType && !itemHeaders['content-type']) itemHeaders['content-type'] = preparedBody.inferredContentType;
         const item = {
             id: itemId,
-            path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+            path: request.itemPath,
             method: request.method,
             headers: itemHeaders,
             ...preparedBody.body ? {
                 body: preparedBody.body
             } : {}
         };
-        const bucketKey = (0, external_codec_js_namespaceObject.stableStringify)({
-            endpoint: request.endpoint,
-            authorization: request.headers.authorization ?? null,
-            cookie: request.headers.cookie ?? null,
-            credentials: request.credentials
-        });
+        const { bucketKey } = request;
         const key = (0, external_codec_js_namespaceObject.stableStringify)({
             bucketKey,
             path: item.path,
@@ -575,13 +541,12 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             }
         }
         bucket.items.push(queued);
-        bucket.bytes = measurePayload(bucket, bucket.items);
         (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
             type: 'enqueue',
             endpoint: request.endpoint,
             size: bucket.items.length
         });
-        if (bucket.items.length >= maxBatchSize || bucket.bytes >= maxBatchBytes) {
+        if (bucket.items.length >= maxBatchSize || measurePayload(bucket, bucket.items) >= maxBatchBytes) {
             flushBucket(bucketKey);
             return queued.promise;
         }

package/dist/cjs/effect/context.js

@@ -28,28 +28,52 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    EFFECT_BFF_CONTEXT_STORAGE_SHARE: ()=>EFFECT_BFF_CONTEXT_STORAGE_SHARE,
+    adoptEffectContextStorage: ()=>adoptEffectContextStorage,
     createEffectOperationContext: ()=>external_operation_context_js_namespaceObject.createEffectOperationContext,
+    getEffectContextStorage: ()=>getEffectContextStorage,
     runWithEffectContext: ()=>runWithEffectContext,
     useEffectContext: ()=>useEffectContext,
     useOperationContext: ()=>useOperationContext
 });
-const external_node_async_hooks_namespaceObject = require("node:async_hooks");
 const external_operation_context_js_namespaceObject = require("./operation-context.js");
 const globalStore = globalThis;
-const effectContextStorage = globalStore[external_operation_context_js_namespaceObject.kEffectContextStorage] ?? (globalStore[external_operation_context_js_namespaceObject.kEffectContextStorage] = new external_node_async_hooks_namespaceObject.AsyncLocalStorage());
-const runWithEffectContext = (context, cb)=>effectContextStorage.run(context, cb);
+const asyncHooks = globalStore.process?.getBuiltinModule?.('node:async_hooks');
+const AsyncLocalStorage = asyncHooks?.AsyncLocalStorage;
+if ('function' != typeof AsyncLocalStorage) throw new Error('[BFF][Effect] The edge runtime must provide AsyncLocalStorage. Enable Node.js compatibility or the nodejs_als compatibility flag.');
+const EFFECT_BFF_CONTEXT_STORAGE_SHARE = '@modern-js/bff-effect/context-storage';
+let effectContextStorage = new AsyncLocalStorage();
+let effectContextStorageUsed = false;
+const usedEffectContextStorage = ()=>{
+    effectContextStorageUsed = true;
+    return effectContextStorage;
+};
+const runWithEffectContext = (context, cb)=>usedEffectContextStorage().run(context, cb);
 const useEffectContext = ()=>{
-    const context = effectContextStorage.getStore();
+    const context = usedEffectContextStorage().getStore();
     if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
     return context;
 };
+const getEffectContextStorage = ()=>effectContextStorage;
+function adoptEffectContextStorage(storage) {
+    const candidate = storage;
+    if ('function' != typeof candidate?.run || 'function' != typeof candidate.getStore) throw new Error(`[BFF][Effect] Share ${EFFECT_BFF_CONTEXT_STORAGE_SHARE} must provide an AsyncLocalStorage.`);
+    if (effectContextStorageUsed && candidate !== effectContextStorage) throw new Error('[BFF][Effect] A backend federation container received the host request storage after an Effect API already used its own. Evaluate exposes only after container init().');
+    effectContextStorage = candidate;
+}
 const useOperationContext = ()=>useEffectContext().operationContext;
+exports.EFFECT_BFF_CONTEXT_STORAGE_SHARE = __webpack_exports__.EFFECT_BFF_CONTEXT_STORAGE_SHARE;
+exports.adoptEffectContextStorage = __webpack_exports__.adoptEffectContextStorage;
 exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.getEffectContextStorage = __webpack_exports__.getEffectContextStorage;
 exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
 exports.useEffectContext = __webpack_exports__.useEffectContext;
 exports.useOperationContext = __webpack_exports__.useOperationContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EFFECT_BFF_CONTEXT_STORAGE_SHARE",
+    "adoptEffectContextStorage",
     "createEffectOperationContext",
+    "getEffectContextStorage",
     "runWithEffectContext",
     "useEffectContext",
     "useOperationContext"

package/dist/cjs/effect/edge-dispatcher.js

@@ -35,16 +35,16 @@ __webpack_require__.d(__webpack_exports__, {
     FetchHttpClient: ()=>http_namespaceObject.FetchHttpClient,
     FindMyWay: ()=>http_namespaceObject.FindMyWay,
     Headers: ()=>http_namespaceObject.Headers,
-    HttpApi: ()=>httpapi_namespaceObject.HttpApi,
-    HttpApiBuilder: ()=>httpapi_namespaceObject.HttpApiBuilder,
-    HttpApiClient: ()=>httpapi_namespaceObject.HttpApiClient,
-    HttpApiEndpoint: ()=>httpapi_namespaceObject.HttpApiEndpoint,
-    HttpApiError: ()=>httpapi_namespaceObject.HttpApiError,
-    HttpApiGroup: ()=>httpapi_namespaceObject.HttpApiGroup,
-    HttpApiMiddleware: ()=>httpapi_namespaceObject.HttpApiMiddleware,
-    HttpApiSchema: ()=>httpapi_namespaceObject.HttpApiSchema,
-    HttpApiSecurity: ()=>httpapi_namespaceObject.HttpApiSecurity,
-    HttpApiTest: ()=>httpapi_namespaceObject.HttpApiTest,
+    HttpApi: ()=>http_api_namespaceObject.HttpApi,
+    HttpApiBuilder: ()=>http_api_namespaceObject.HttpApiBuilder,
+    HttpApiClient: ()=>http_api_namespaceObject.HttpApiClient,
+    HttpApiEndpoint: ()=>http_api_namespaceObject.HttpApiEndpoint,
+    HttpApiError: ()=>http_api_namespaceObject.HttpApiError,
+    HttpApiGroup: ()=>http_api_namespaceObject.HttpApiGroup,
+    HttpApiMiddleware: ()=>http_api_namespaceObject.HttpApiMiddleware,
+    HttpApiSchema: ()=>http_api_namespaceObject.HttpApiSchema,
+    HttpApiSecurity: ()=>http_api_namespaceObject.HttpApiSecurity,
+    HttpApiTest: ()=>http_api_namespaceObject.HttpApiTest,
     HttpBody: ()=>http_namespaceObject.HttpBody,
     HttpClient: ()=>http_namespaceObject.HttpClient,
     HttpClientError: ()=>http_namespaceObject.HttpClientError,
@@ -67,7 +67,7 @@ __webpack_require__.d(__webpack_exports__, {
     Layer: ()=>Layer_namespaceObject,
     Multipart: ()=>http_namespaceObject.Multipart,
     MultipartParser: ()=>http_namespaceObject.MultipartParser,
-    OpenApi: ()=>httpapi_namespaceObject.OpenApi,
+    OpenApi: ()=>http_api_namespaceObject.OpenApi,
     Option: ()=>Option_namespaceObject,
     Rpc: ()=>rpc_namespaceObject.Rpc,
     RpcClient: ()=>rpc_namespaceObject.RpcClient,
@@ -93,23 +93,23 @@ __webpack_require__.d(__webpack_exports__, {
     defineEffectBff: ()=>external_handler_js_namespaceObject.defineEffectBff,
     defineEffectRpcBff: ()=>external_handler_js_namespaceObject.defineEffectRpcBff,
     dispatchEffectBffRequest: ()=>dispatchEffectBffRequest,
-    runWithEffectContext: ()=>external_edge_context_js_namespaceObject.runWithEffectContext,
-    useEffectContext: ()=>external_edge_context_js_namespaceObject.useEffectContext,
-    useOperationContext: ()=>external_edge_context_js_namespaceObject.useOperationContext
+    runWithEffectContext: ()=>context_namespaceObject.runWithEffectContext,
+    useEffectContext: ()=>context_namespaceObject.useEffectContext,
+    useOperationContext: ()=>context_namespaceObject.useOperationContext
 });
+const context_namespaceObject = require("@modern-js/bff-effect/context");
 const bff_policy_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy");
 const Effect_namespaceObject = require("effect/Effect");
 const external_headers_js_namespaceObject = require("../headers.js");
 const external_dispatch_js_namespaceObject = require("./dispatch.js");
-const external_edge_context_js_namespaceObject = require("./edge-context.js");
 const external_module_js_namespaceObject = require("./module.js");
 const Config_namespaceObject = require("effect/Config");
+const http_namespaceObject = require("effect/http");
+const http_api_namespaceObject = require("effect/http-api");
 const Layer_namespaceObject = require("effect/Layer");
 const Option_namespaceObject = require("effect/Option");
+const rpc_namespaceObject = require("effect/rpc");
 const Schema_namespaceObject = require("effect/Schema");
-const http_namespaceObject = require("effect/unstable/http");
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
-const rpc_namespaceObject = require("effect/unstable/rpc");
 const external_handler_js_namespaceObject = require("./handler.js");
 const external_operation_context_js_namespaceObject = require("./operation-context.js");
 const NORMALIZED_POLICY_BOOLEAN_FIELDS = [
@@ -136,7 +136,7 @@ function restoreEffectBffMountPath(request, prefix) {
 async function dispatchEffectBffRequest(handler, request, options = {}) {
     return (0, external_dispatch_js_namespaceObject.dispatchEffectBffRequestWithContext)(handler, request, {
         ...options,
-        runWithEffectContext: external_edge_context_js_namespaceObject.runWithEffectContext
+        runWithEffectContext: context_namespaceObject.runWithEffectContext
     });
 }
 async function createEffectBffEdgeDispatcher(options) {

package/dist/cjs/effect/edge.js

@@ -3,8 +3,14 @@ var __webpack_modules__ = {
     "./edge-dispatcher" (module) {
         module.exports = require("./edge-dispatcher.js");
     },
+    "./entry-shape" (module) {
+        module.exports = require("./entry-shape.js");
+    },
     "./generated-entry" (module) {
         module.exports = require("./generated-entry.js");
+    },
+    "@modern-js/bff-effect/context" (module) {
+        module.exports = require("@modern-js/bff-effect/context");
     }
 };
 var __webpack_module_cache__ = {};
@@ -54,20 +60,34 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _edge_dispatcher__rspack_import_0 = __webpack_require__("./edge-dispatcher");
+    var _modern_js_bff_effect_context__rspack_import_0 = __webpack_require__("@modern-js/bff-effect/context");
+    var _edge_dispatcher__rspack_import_1 = __webpack_require__("./edge-dispatcher");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _edge_dispatcher__rspack_import_0)if ([
+    for(const __rspack_import_key in _edge_dispatcher__rspack_import_1)if ([
+        "EFFECT_BFF_CONTEXT_STORAGE_SHARE",
+        "default",
+        "EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE",
         "createEffectBffEdgeDispatcherFactory",
-        "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_edge_dispatcher__rspack_import_0[__rspack_import_key];
+        "adoptEffectBffShareScope"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_edge_dispatcher__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _generated_entry__rspack_import_1 = __webpack_require__("./generated-entry");
+    var _entry_shape__rspack_import_2 = __webpack_require__("./entry-shape");
+    var _generated_entry__rspack_import_3 = __webpack_require__("./generated-entry");
     __webpack_require__.d(__webpack_exports__, {
-        createEffectBffEdgeDispatcherFactory: ()=>_generated_entry__rspack_import_1.createEffectBffEdgeDispatcherFactory
+        EFFECT_BFF_CONTEXT_STORAGE_SHARE: ()=>_modern_js_bff_effect_context__rspack_import_0.EFFECT_BFF_CONTEXT_STORAGE_SHARE,
+        EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE: ()=>_entry_shape__rspack_import_2.EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE,
+        adoptEffectBffShareScope: ()=>_entry_shape__rspack_import_2.adoptEffectBffShareScope,
+        createEffectBffEdgeDispatcherFactory: ()=>_generated_entry__rspack_import_3.createEffectBffEdgeDispatcherFactory
     });
 })();
+exports.EFFECT_BFF_CONTEXT_STORAGE_SHARE = __webpack_exports__.EFFECT_BFF_CONTEXT_STORAGE_SHARE;
+exports.EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE = __webpack_exports__.EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE;
+exports.adoptEffectBffShareScope = __webpack_exports__.adoptEffectBffShareScope;
 exports.createEffectBffEdgeDispatcherFactory = __webpack_exports__.createEffectBffEdgeDispatcherFactory;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EFFECT_BFF_CONTEXT_STORAGE_SHARE",
+    "EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE",
+    "adoptEffectBffShareScope",
     "createEffectBffEdgeDispatcherFactory"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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) {
@@ -91,18 +122,15 @@ function createEntryShapeFacts(module, predicates, unsupportedShape) {
         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/handler/batch-handler.js

@@ -32,6 +32,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 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");
@@ -123,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)=>{

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

@@ -32,7 +32,6 @@ __webpack_require__.d(__webpack_exports__, {
     createBatchValidationResponse: ()=>createBatchValidationResponse,
     isBatchRequestPayload: ()=>isBatchRequestPayload,
     mapWithConcurrency: ()=>mapWithConcurrency,
-    normalizeBatchAllowedMethods: ()=>normalizeBatchAllowedMethods,
     normalizeBatchPath: ()=>normalizeBatchPath,
     prepareJsonRequestBody: ()=>prepareJsonRequestBody,
     promiseWithTimeout: ()=>promiseWithTimeout,
@@ -48,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);
 }
@@ -154,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;
@@ -165,7 +157,6 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createBatchValidationResponse",
     "isBatchRequestPayload",
     "mapWithConcurrency",
-    "normalizeBatchAllowedMethods",
     "normalizeBatchPath",
     "prepareJsonRequestBody",
     "promiseWithTimeout",

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

@@ -30,8 +30,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createHttpApiHandler: ()=>createHttpApiHandler
 });
+const http_namespaceObject = require("effect/http");
 const Layer_namespaceObject = require("effect/Layer");
-const http_namespaceObject = require("effect/unstable/http");
 const external_batch_js_namespaceObject = require("./batch.js");
 const external_batch_handler_js_namespaceObject = require("./batch-handler.js");
 const external_envelope_js_namespaceObject = require("./envelope.js");