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

package/README.md

@@ -1,7 +1,7 @@
 # @modern-js/bff-effect
 
 Fork-owned Effect primitives for UltraModern.js BFF runtimes. The package
-keeps the portable Effect handler, data-platform, generated-client runtime,
+keeps the portable Effect handler, data-platform, native inferred clients,
 and edge dispatcher behind standalone package entry points rather than growing
 the upstream-owned `@modern-js/plugin-bff` implementation.
 
@@ -16,10 +16,26 @@ upstream Modern.js project.
 - `@modern-js/bff-effect/effect-edge` exposes the edge-safe dispatcher without
   a static Node built-in import.
 - `@modern-js/bff-effect/effect-client` exposes the Effect client runtime.
-- `@modern-js/bff-effect/effect-client-runtime` exposes the generated-client
-  runtime helpers.
 - `@modern-js/bff-effect/data-platform` exposes batching, envelope, tracing,
   validation, and invalidation primitives.
 
-Adapter lifecycle integration, Hono integration, source/client generation, and
+Adapter lifecycle integration, Hono integration, server source loading, and
 backend federation are intentionally owned by their respective packages.
+
+## HTTP clients
+
+Keep the `HttpApi` contract in a shared module and pass it to Effect's
+`HttpApiClient.make` or `makeEffectHttpApiClient` from `/effect-client`.
+Requests, responses, and declared errors are inferred from that contract.
+No SDK generation or backend-entry import is required.
+
+`defineEffectBff` creates server handlers. Its former `client` placeholder,
+the `@api/index` client transform, and `/effect-client-runtime` have been
+removed. Move consumers to the shared contract and execute native client
+operations with Effect.
+
+For APIs hosted through a cross-project plugin, pass `crossProject` to the
+native client helper: `{ requestId: 'catalog', operationVersion: 2, prefix: '/api' }`.
+Use the producer's request ID, package major version, and server mount path.
+Effect HTTP middleware derives operation headers from the shared contract;
+the server continues to reject missing or stale contract headers.

package/dist/cjs/assembly.js

@@ -0,0 +1,50 @@
+"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__, {
+    assembleEffectBffRuntime: ()=>assembleEffectBffRuntime
+});
+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 layer = void 0 === transport ? apiLayer : apiLayer.pipe(Layer_namespaceObject.merge(transport));
+    return (0, definition_js_namespaceObject.defineEffectBff)({
+        api,
+        layer
+    });
+};
+exports.assembleEffectBffRuntime = __webpack_exports__.assembleEffectBffRuntime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assembleEffectBffRuntime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/{effect-client/guards.js → data-platform/batch/options.js}

@@ -27,17 +27,21 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const isRecord = (value)=>'object' == typeof value && null !== value;
-const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
-__webpack_require__.d(__webpack_exports__, {}, {
-    isRecord: isRecord,
-    stringOrUndefined: stringOrUndefined
+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.isRecord = __webpack_exports__.isRecord;
-exports.stringOrUndefined = __webpack_exports__.stringOrUndefined;
+exports.normalizeBatchLimits = __webpack_exports__.normalizeBatchLimits;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "isRecord",
-    "stringOrUndefined"
+    "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/data-platform/trace.js

@@ -32,7 +32,7 @@ __webpack_require__.d(__webpack_exports__, {
     formatTraceparentHeader: ()=>formatTraceparentHeader,
     parseTraceparentHeader: ()=>parseTraceparentHeader
 });
-const create_request_namespaceObject = require("@modern-js/create-request");
+const request_context_namespaceObject = require("@modern-js/runtime-extensions/request-context");
 function isAllZeroHex(value) {
     return /^0+$/.test(value);
 }
@@ -40,7 +40,7 @@ function isValidHex(value, length) {
     return value.length === length && /^[0-9a-f]+$/.test(value);
 }
 function parseTraceparentHeader(header) {
-    return (0, create_request_namespaceObject.parseTraceparent)(header) ?? null;
+    return (0, request_context_namespaceObject.parseTraceparent)(header) ?? null;
 }
 function formatTraceparentHeader(trace) {
     const traceId = trace.traceId.toLowerCase();

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

@@ -93,17 +93,17 @@ __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 cross_project_policy_namespaceObject = require("@modern-js/bff-core/security/cross-project-policy");
+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 Effect_namespaceObject = require("effect/Effect");
 const Layer_namespaceObject = require("effect/Layer");
 const Option_namespaceObject = require("effect/Option");
 const Schema_namespaceObject = require("effect/Schema");
@@ -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) {
@@ -147,14 +147,14 @@ async function createEffectBffEdgeDispatcher(options) {
         dataPlatform: options.dataPlatform,
         validateRequest: crossProjectPolicy?.enabled === true ? (request)=>{
             const pathname = new URL(request.url).pathname;
-            const observedRequest = (0, cross_project_policy_namespaceObject.resolveCrossProjectRequestObservation)({
+            const observedRequest = (0, bff_policy_namespaceObject.resolveCrossProjectRequestObservation)({
                 method: request.method,
                 pathname
             }, crossProjectPolicy) ?? {
                 method: request.method,
                 routePath: restoreEffectBffMountPath(request, options.prefix)
             };
-            const violation = (0, cross_project_policy_namespaceObject.evaluateCrossProjectPolicy)((0, external_headers_js_namespaceObject.toHeaderRecord)(request.headers), crossProjectPolicy, observedRequest);
+            const violation = (0, bff_policy_namespaceObject.evaluateCrossProjectPolicy)((0, external_headers_js_namespaceObject.toHeaderRecord)(request.headers), crossProjectPolicy, observedRequest);
             if (!violation) return null;
             return new Response(JSON.stringify({
                 code: violation.code,
@@ -194,9 +194,9 @@ async function createEffectBffEdgeDispatcher(options) {
         dispose: ()=>{
             disposePromise ??= (async ()=>{
                 acceptingRequests = false;
-                if (activeDispatches > 0) await new Promise((resolve)=>{
-                    resolveDrain = resolve;
-                });
+                if (activeDispatches > 0) await Effect_namespaceObject.runPromise(Effect_namespaceObject.callback((resume)=>{
+                    resolveDrain = ()=>resume(Effect_namespaceObject["void"]);
+                }));
                 await loaded.dispose?.();
             })();
             return disposePromise;

package/dist/cjs/effect/edge.js

@@ -2,6 +2,15 @@
 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__ = {};
@@ -51,12 +60,36 @@ 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 ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_edge_dispatcher__rspack_import_0[__rspack_import_key];
+    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",
+        "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 _entry_shape__rspack_import_2 = __webpack_require__("./entry-shape");
+    var _generated_entry__rspack_import_3 = __webpack_require__("./generated-entry");
+    __webpack_require__.d(__webpack_exports__, {
+        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
+    });
 })();
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+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', {
     value: true
 });

package/dist/cjs/effect/endpoint-contracts.js

@@ -35,11 +35,10 @@ __webpack_require__.d(__webpack_exports__, {
     normalizeEffectPrefix: ()=>normalizeEffectPrefix,
     toOperationContractSources: ()=>toOperationContractSources
 });
-const bff_core_namespaceObject = require("@modern-js/bff-core");
+const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
 const external_entry_shape_js_namespaceObject = require("./entry-shape.js");
 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) {
@@ -97,10 +96,10 @@ async function extractHttpApiFromModule(mod, isHttpApi) {
         isValidatorAwareHandlerFactory: external_entry_shape_js_namespaceObject.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 (0, bff_core_namespaceObject.createOperationContractHash)(createEffectOperationContractSource(endpoint), requestId);
+    return (0, node_namespaceObject.createOperationContractHash)(createEffectOperationContractSource(endpoint), requestId);
 }
 exports.collectEffectEndpoints = __webpack_exports__.collectEffectEndpoints;
 exports.createEffectEndpointContractHash = __webpack_exports__.createEffectEndpointContractHash;