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

package/dist/cjs/microvertical-api.js

@@ -0,0 +1,120 @@
+"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__, {
+    MicroVerticalBuildMarkerSchema: ()=>MicroVerticalBuildMarkerSchema,
+    MicroVerticalOperationContextSchema: ()=>MicroVerticalOperationContextSchema,
+    MicroVerticalOperationSourceSchema: ()=>MicroVerticalOperationSourceSchema,
+    MicroVerticalReadinessSchema: ()=>MicroVerticalReadinessSchema,
+    createMicroVerticalOperationContext: ()=>createMicroVerticalOperationContext,
+    microVerticalOperationAttributes: ()=>microVerticalOperationAttributes
+});
+const external_effect_namespaceObject = require("effect");
+const MicroVerticalAppIdSchema = external_effect_namespaceObject.Schema.String.pipe(external_effect_namespaceObject.Schema.brand('MicroVerticalAppId'), external_effect_namespaceObject.Schema.decodeTo(external_effect_namespaceObject.Schema.String));
+const MicroVerticalUnitIdSchema = external_effect_namespaceObject.Schema.String.pipe(external_effect_namespaceObject.Schema.brand('MicroVerticalUnitId'), external_effect_namespaceObject.Schema.decodeTo(external_effect_namespaceObject.Schema.String));
+const MicroVerticalOperationIdSchema = external_effect_namespaceObject.Schema.String.pipe(external_effect_namespaceObject.Schema.brand('MicroVerticalOperationId'), external_effect_namespaceObject.Schema.decodeTo(external_effect_namespaceObject.Schema.String));
+const MicroVerticalTraceIdSchema = external_effect_namespaceObject.Schema.String.pipe(external_effect_namespaceObject.Schema.brand('MicroVerticalTraceId'), external_effect_namespaceObject.Schema.decodeTo(external_effect_namespaceObject.Schema.String));
+const MicroVerticalBuildMarkerSchema = external_effect_namespaceObject.Schema.Struct({
+    appId: MicroVerticalAppIdSchema,
+    build: external_effect_namespaceObject.Schema.String,
+    buildMarker: external_effect_namespaceObject.Schema.String,
+    deployProfile: external_effect_namespaceObject.Schema.String,
+    packageName: external_effect_namespaceObject.Schema.String,
+    sourceRevision: external_effect_namespaceObject.Schema.String,
+    surface: external_effect_namespaceObject.Schema.String,
+    unitId: MicroVerticalUnitIdSchema,
+    version: external_effect_namespaceObject.Schema.String
+});
+const MicroVerticalReadinessSchema = external_effect_namespaceObject.Schema.Struct({
+    checks: external_effect_namespaceObject.Schema.Struct({
+        api: external_effect_namespaceObject.Schema.Literal('ready'),
+        moduleFederation: external_effect_namespaceObject.Schema.Literal('ready'),
+        ssr: external_effect_namespaceObject.Schema.Literal('ready'),
+        translations: external_effect_namespaceObject.Schema.Literal('ready')
+    }),
+    marker: MicroVerticalBuildMarkerSchema,
+    status: external_effect_namespaceObject.Schema.Literal('ready'),
+    versionSkew: external_effect_namespaceObject.Schema.Literal('none')
+});
+const MicroVerticalOperationSourceSchema = external_effect_namespaceObject.Schema.Literals([
+    'client',
+    'server',
+    'generated-client',
+    'effect-server',
+    'data-platform',
+    'unknown'
+]);
+const MicroVerticalOperationContextSchema = external_effect_namespaceObject.Schema.Struct({
+    method: external_effect_namespaceObject.Schema.String,
+    operationId: MicroVerticalOperationIdSchema,
+    routePath: external_effect_namespaceObject.Schema.String,
+    source: MicroVerticalOperationSourceSchema,
+    traceId: external_effect_namespaceObject.Schema.optionalKey(MicroVerticalTraceIdSchema)
+});
+const createMicroVerticalOperationContext = (input)=>{
+    const context = {
+        method: input.method,
+        operationId: input.operationId,
+        routePath: input.routePath,
+        source: 'generated-client'
+    };
+    return void 0 === input.traceId ? context : {
+        ...context,
+        traceId: input.traceId
+    };
+};
+const microVerticalOperationAttributes = (operationContext)=>{
+    const attributes = {
+        'modernjs.operation.id': operationContext.operationId,
+        'modernjs.operation.method': operationContext.method,
+        'modernjs.operation.route': operationContext.routePath,
+        'modernjs.operation.source': operationContext.source
+    };
+    return void 0 === operationContext.traceId ? attributes : {
+        ...attributes,
+        'modernjs.trace.id': operationContext.traceId
+    };
+};
+exports.MicroVerticalBuildMarkerSchema = __webpack_exports__.MicroVerticalBuildMarkerSchema;
+exports.MicroVerticalOperationContextSchema = __webpack_exports__.MicroVerticalOperationContextSchema;
+exports.MicroVerticalOperationSourceSchema = __webpack_exports__.MicroVerticalOperationSourceSchema;
+exports.MicroVerticalReadinessSchema = __webpack_exports__.MicroVerticalReadinessSchema;
+exports.createMicroVerticalOperationContext = __webpack_exports__.createMicroVerticalOperationContext;
+exports.microVerticalOperationAttributes = __webpack_exports__.microVerticalOperationAttributes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MicroVerticalBuildMarkerSchema",
+    "MicroVerticalOperationContextSchema",
+    "MicroVerticalOperationSourceSchema",
+    "MicroVerticalReadinessSchema",
+    "createMicroVerticalOperationContext",
+    "microVerticalOperationAttributes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/assembly.mjs

@@ -0,0 +1,12 @@
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { defineEffectBff } from "./effect/handler/definition.mjs";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+const assembleEffectBffRuntime = ({ api, handlers, transport })=>{
+    const apiLayer = HttpApiBuilder.layer(api).pipe(__rspack_external_effect_Layer_69c46453.provide(handlers));
+    const layer = void 0 === transport ? apiLayer : apiLayer.pipe(__rspack_external_effect_Layer_69c46453.merge(transport));
+    return defineEffectBff({
+        api,
+        layer
+    });
+};
+export { assembleEffectBffRuntime };

package/dist/esm/data-platform/batch/options.mjs

@@ -0,0 +1,10 @@
+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()))
+    };
+}
+export { normalizeBatchLimits };

package/dist/esm/data-platform/batch/queue.mjs

@@ -1,5 +1,6 @@
 import { stableStringify } from "../codec.mjs";
 import { DEFAULT_DATA_BATCH_HEADER } from "../types.mjs";
+import { normalizeBatchLimits } from "./options.mjs";
 import { decodeBatchBody, isNullBodyStatus } from "./protocol.mjs";
 import { createBatchId, measureTextBytes, normalizeMethod, shouldBatchRequest, toHeaderRecord, toRequestBody } from "./request.mjs";
 import { isBatchResponsePayload, parseResponseLikeCreateRequest } from "./response.mjs";
@@ -78,7 +79,6 @@ class BatchBucketRegistry {
         if (existing) return existing;
         const next = {
             items: [],
-            bytes: 0,
             batchId: createBatchId(),
             sentAt: Date.now(),
             timer: null,
@@ -97,12 +97,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 } = 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();
@@ -135,7 +131,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;
@@ -177,7 +172,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;
@@ -194,7 +193,6 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             sentAt: bucket.sentAt
         };
         bucket.items = [];
-        bucket.bytes = 0;
         rotatePayloadIdentity(bucket);
         const firstItem = items[0];
         if (!firstItem) {
@@ -210,14 +208,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)=>{
+            emitDataBatchTransportEvent(onEvent, {
+                type: 'fallback',
+                endpoint,
+                batchId,
+                size: items.length,
+                reason
+            });
+            return settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+        };
         emitDataBatchTransportEvent(onEvent, {
             type: 'flush',
             endpoint,
@@ -268,42 +277,13 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                         batchId,
                         reason: `batch-endpoint-unavailable-${String(response.status)}`
                     });
-                } else 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 (!isBatchResponsePayload(result)) {
-                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) {
-                emitDataBatchTransportEvent(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: 'mismatched-batch-id'
-                });
-                await settleAmbiguousBatchRequests(items, 'mismatched-batch-id');
-                bucket.flushing = false;
-                return;
-            }
+            if (!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)=>{
@@ -327,19 +307,10 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                 });
                 return;
             }
-            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();
@@ -363,7 +334,20 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const sourceSignal = initDefinesSignal ? initSignal ?? void 0 : sourceRequest?.signal;
         const requestUrl = toAbsoluteUrl(input);
         const endpoint = normalizeBatchEndpoint(requestUrl, options.endpoint).toString();
+        const itemHeaders = {
+            ...headers
+        };
+        delete itemHeaders.authorization;
+        delete itemHeaders.cookie;
         return {
+            itemHeaders,
+            itemPath: `${requestUrl.pathname}${requestUrl.search}`,
+            bucketKey: stableStringify({
+                endpoint,
+                authorization: headers.authorization ?? null,
+                cookie: headers.cookie ?? null,
+                credentials
+            }),
             requestUrl,
             endpoint,
             method,
@@ -396,22 +380,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 = stableStringify({
-            endpoint: request.endpoint,
-            authorization: request.headers.authorization ?? null,
-            cookie: request.headers.cookie ?? null,
-            credentials: request.credentials
-        });
         return 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
         });
     };
@@ -429,26 +402,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 = stableStringify({
-            endpoint: request.endpoint,
-            authorization: request.headers.authorization ?? null,
-            cookie: request.headers.cookie ?? null,
-            credentials: request.credentials
-        });
+        const { bucketKey } = request;
         const key = stableStringify({
             bucketKey,
             path: item.path,
@@ -542,13 +508,12 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             }
         }
         bucket.items.push(queued);
-        bucket.bytes = measurePayload(bucket, bucket.items);
         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/esm/data-platform/trace.mjs

@@ -1,4 +1,4 @@
-import { parseTraceparent } from "@modern-js/create-request";
+import { parseTraceparent } from "@modern-js/runtime-extensions/request-context";
 function isAllZeroHex(value) {
     return /^0+$/.test(value);
 }

package/dist/esm/effect/context.mjs

@@ -1,12 +1,27 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { createEffectOperationContext, kEffectContextStorage } from "./operation-context.mjs";
 const globalStore = globalThis;
-const effectContextStorage = globalStore[kEffectContextStorage] ?? (globalStore[kEffectContextStorage] = new 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;
-export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext };
+export { createEffectOperationContext } from "./operation-context.mjs";
+export { EFFECT_BFF_CONTEXT_STORAGE_SHARE, adoptEffectContextStorage, getEffectContextStorage, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm/effect/edge-dispatcher.mjs

@@ -1,10 +1,10 @@
-import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/bff-core/security/cross-project-policy";
+import { runWithEffectContext, useEffectContext, useOperationContext } from "@modern-js/bff-effect/context";
+import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/server-runtime-extensions/bff-policy";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
 import { toHeaderRecord } from "../headers.mjs";
 import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
-import { runWithEffectContext, useEffectContext, useOperationContext } from "./edge-context.mjs";
 import { resolveEffectBffModuleHandler } from "./module.mjs";
 import * as __rspack_external_effect_Config_76cfa59d from "effect/Config";
-import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
 import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
 import * as __rspack_external_effect_Option_0498e63a from "effect/Option";
 import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
@@ -90,9 +90,9 @@ async function createEffectBffEdgeDispatcher(options) {
         dispose: ()=>{
             disposePromise ??= (async ()=>{
                 acceptingRequests = false;
-                if (activeDispatches > 0) await new Promise((resolve)=>{
-                    resolveDrain = resolve;
-                });
+                if (activeDispatches > 0) await __rspack_external_effect_Effect_41060786.runPromise(__rspack_external_effect_Effect_41060786.callback((resume)=>{
+                    resolveDrain = ()=>resume(__rspack_external_effect_Effect_41060786["void"]);
+                }));
                 await loaded.dispose?.();
             })();
             return disposePromise;

package/dist/esm/effect/edge.mjs

@@ -1 +1,4 @@
 export * from "./edge-dispatcher.mjs";
+export { EFFECT_BFF_CONTEXT_STORAGE_SHARE } from "@modern-js/bff-effect/context";
+export { EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE, adoptEffectBffShareScope } from "./entry-shape.mjs";
+export { createEffectBffEdgeDispatcherFactory } from "./generated-entry.mjs";

package/dist/esm/effect/endpoint-contracts.mjs

@@ -1,8 +1,7 @@
-import { createOperationContractHash } from "@modern-js/bff-core";
+import { createOperationContractHash } from "@modern-js/server-runtime-extensions/bff-policy/node";
 import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
 function resolveEffectEndpointName(endpoint) {
     if ('string' == typeof endpoint.identifier && endpoint.identifier) return endpoint.identifier;
-    if ('string' == typeof endpoint.name && endpoint.name) return endpoint.name;
     return '';
 }
 function ensureLeadingSlash(pathname) {
@@ -60,7 +59,7 @@ async function extractHttpApiFromModule(mod, isHttpApi) {
         isValidatorAwareHandlerFactory: isValidatorAwareHandlerFactory,
         isHttpApi
     });
-    return !facts?.legacyShape && facts?.api !== void 0 && facts.hasRuntimeLayer && (void 0 === facts.createHandler || facts.createHandlerValidatorAware) ? facts.api : null;
+    return !facts?.unsupportedShape && facts?.api !== void 0 && facts.hasRuntimeLayer && (void 0 === facts.createHandler || facts.createHandlerValidatorAware) ? facts.api : null;
 }
 function createEffectEndpointContractHash(endpoint, requestId) {
     return createOperationContractHash(createEffectOperationContractSource(endpoint), requestId);

package/dist/esm/effect/entry-shape-registry.mjs

@@ -1,7 +1,7 @@
 "use strict";
 import { __webpack_require__ } from "../rslib-runtime~1.mjs";
 __webpack_require__.add({
-    1970 (module) {
+    Oz (module) {
         const validatorAwareHandlerFactories = new WeakSet();
         module.exports = {
             register (factory) {
@@ -14,4 +14,4 @@ __webpack_require__.add({
         };
     }
 });
-__webpack_require__("1970");
+__webpack_require__("Oz");

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

@@ -1,3 +1,5 @@
+import { EFFECT_BFF_CONTEXT_STORAGE_SHARE, adoptEffectContextStorage } from "@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 {
@@ -10,12 +12,33 @@ function createLocalValidatorAwareHandlerFactoryRegistry() {
         }
     };
 }
-const validatorAwareHandlerFactoryRegistry = createLocalValidatorAwareHandlerFactoryRegistry();
+let validatorAwareHandlerFactoryRegistry;
+function handlerFactoryRegistry() {
+    validatorAwareHandlerFactoryRegistry ??= createLocalValidatorAwareHandlerFactoryRegistry();
+    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, EFFECT_BFF_CONTEXT_STORAGE_SHARE, 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) {
@@ -34,13 +57,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,
@@ -48,4 +71,4 @@ function createEntryShapeFacts(module, predicates, legacyShape) {
         hasRuntimeLayer
     };
 }
-export { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, registerValidatorAwareHandlerFactory, strictEffectApproachMessage };
+export { EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE, adoptEffectBffShareScope, classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, registerValidatorAwareHandlerFactory, strictEffectApproachMessage };

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

@@ -0,0 +1,19 @@
+import { createEffectBffEdgeDispatcher } from "./edge-dispatcher.mjs";
+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 createEffectBffEdgeDispatcher({
+            ...options,
+            crossProjectPolicy,
+            module
+        });
+    };
+}
+export { createEffectBffEdgeDispatcherFactory };

package/dist/esm/effect/handler/batch-handler.mjs

@@ -1,7 +1,9 @@
 import { DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, decodeRequestEnvelopeHeader, isPlainObject, normalizeMethod } from "../../data-platform/index.mjs";
+import { normalizeBatchLimits } from "../../data-platform/batch/options.mjs";
 import { decodeBatchBody, isBatchBody, toBatchResponseItem } from "../../data-platform/batch/protocol.mjs";
-import { BatchItemTimeoutError, createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchAllowedMethods, normalizeBatchPath, promiseWithTimeout, toBatchItemError } from "./batch.mjs";
+import { BatchItemTimeoutError, createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchPath, promiseWithTimeout, toBatchItemError } from "./batch.mjs";
 import { getMountedPrefixFromContext, removeMountedPrefixFromBatchPath } from "./routing.mjs";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
 const HOP_BY_HOP_BATCH_ITEM_HEADERS = new Set([
     'connection',
     'keep-alive',
@@ -90,11 +92,9 @@ function createDataPlatformBatchRequestHandler(options) {
     const dataPlatformBatchOptions = options.dataPlatform?.batch;
     const batchEnabled = dataPlatformBatchOptions?.enabled !== false;
     const batchPath = 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 } = normalizeBatchLimits(dataPlatformBatchOptions);
     const batchConcurrency = Math.max(1, dataPlatformBatchOptions?.maxConcurrency ?? 4);
     const batchItemTimeoutMs = Math.max(0, dataPlatformBatchOptions?.requestTimeoutMs ?? 10000);
-    const batchAllowedMethods = normalizeBatchAllowedMethods(dataPlatformBatchOptions?.allowedMethods);
     const envelopeHeader = options.dataPlatform?.envelopeHeader || DEFAULT_DATA_ENVELOPE_HEADER;
     const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
     const handle = async (request, context)=>{
@@ -184,25 +184,25 @@ function createDataPlatformBatchRequestHandler(options) {
                 return toBatchResponseItem(itemId, itemResponse, 'HEAD' === itemMethod);
             } catch (error) {
                 if (error instanceof BatchItemTimeoutError) {
-                    console.error({
+                    __rspack_external_effect_Effect_41060786.runSync(__rspack_external_effect_Effect_41060786.logError({
                         event: 'bff.batch.item.timeout',
                         batchId: payload.batchId,
                         itemId,
                         method: itemMethod,
                         path: itemPathname,
                         errorName: error.name
-                    });
+                    }));
                     return toBatchItemError(itemId, 504, 'Batch item request timed out');
                 }
                 if (error instanceof Response) return toBatchResponseItem(itemId, error, 'HEAD' === itemMethod);
-                console.error({
+                __rspack_external_effect_Effect_41060786.runSync(__rspack_external_effect_Effect_41060786.logError({
                     event: 'bff.batch.item.failure',
                     batchId: payload.batchId,
                     itemId,
                     method: itemMethod,
                     path: itemPathname,
                     errorName: error instanceof Error ? error.name : 'UnknownError'
-                });
+                }));
                 return toBatchItemError(itemId, 500, 'Internal Server Error');
             } finally{
                 request.signal.removeEventListener('abort', abortFromBatchRequest);