@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

package/dist/cjs/runtime/effect/backend-federation-manifest.js

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_modules__ = {
+    "./backend-federation-manifest/index" (module) {
+        module.exports = require("./backend-federation-manifest/index.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+    var _backend_federation_manifest_index__rspack_import_0 = __webpack_require__("./backend-federation-manifest/index");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _backend_federation_manifest_index__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_backend_federation_manifest_index__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/backend-federation.js

@@ -0,0 +1,61 @@
+"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__, {
+    BACKEND_FEDERATION_CONTRACT_VERSION: ()=>universal_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION,
+    BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE,
+    BACKEND_FEDERATION_MANIFEST_FILE: ()=>universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+    BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>universal_namespaceObject.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+    createBackendFederationLoadEntryPlugin: ()=>plugin_js_namespaceObject.createBackendFederationLoadEntryPlugin,
+    createBackendFederationRuntime: ()=>runtime_js_namespaceObject.createBackendFederationRuntime,
+    loadBackendFederatedEffectApi: ()=>load_js_namespaceObject.loadBackendFederatedEffectApi
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const load_js_namespaceObject = require("./backend-federation/load.js");
+const plugin_js_namespaceObject = require("./backend-federation/plugin.js");
+const runtime_js_namespaceObject = require("./backend-federation/runtime.js");
+exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
+exports.BACKEND_FEDERATION_EFFECT_EXPOSE = __webpack_exports__.BACKEND_FEDERATION_EFFECT_EXPOSE;
+exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_FILE;
+exports.BACKEND_FEDERATION_NODE_ADAPTER_VERSION = __webpack_exports__.BACKEND_FEDERATION_NODE_ADAPTER_VERSION;
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
+exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_CONTRACT_VERSION",
+    "BACKEND_FEDERATION_EFFECT_EXPOSE",
+    "BACKEND_FEDERATION_MANIFEST_FILE",
+    "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
+    "createBackendFederationLoadEntryPlugin",
+    "createBackendFederationRuntime",
+    "loadBackendFederatedEffectApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/dispatch.js

@@ -0,0 +1,101 @@
+"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__, {
+    dispatchEffectBffRequestWithContext: ()=>dispatchEffectBffRequestWithContext
+});
+const external_safe_failure_js_namespaceObject = require("../safe-failure.js");
+const external_operation_context_js_namespaceObject = require("./operation-context.js");
+function normalizeEffectBffPrefix(prefix) {
+    if (!prefix || '/' === prefix) return '';
+    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+}
+function removeEffectBffPrefixFromPath(pathname, prefix) {
+    const normalized = normalizeEffectBffPrefix(prefix);
+    if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
+    const sliced = pathname.slice(normalized.length);
+    return sliced.startsWith('/') ? sliced : `/${sliced}`;
+}
+function matchesEffectBffPrefix(pathname, prefix) {
+    const normalized = normalizeEffectBffPrefix(prefix);
+    return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function createEffectBffMountedRequest(req, prefix) {
+    const url = new URL(req.url);
+    const nextPath = removeEffectBffPrefixFromPath(url.pathname, prefix);
+    if (nextPath !== url.pathname) {
+        url.pathname = nextPath;
+        return new Request(url, req);
+    }
+    return req;
+}
+function createEffectBffDispatchContext(originalRequest, mountedRequest, options) {
+    const path = options.path ?? new URL(originalRequest.url).pathname;
+    const method = options.method ?? originalRequest.method;
+    const env = options.env ?? {};
+    return {
+        request: mountedRequest,
+        env,
+        path,
+        method,
+        operationContext: (0, external_operation_context_js_namespaceObject.createEffectOperationContext)({
+            request: mountedRequest,
+            env,
+            path,
+            method
+        })
+    };
+}
+async function dispatchEffectBffRequestWithContext(handler, request, options) {
+    const requestPath = new URL(request.url).pathname;
+    if (!matchesEffectBffPrefix(requestPath, options.prefix)) return new Response('', {
+        status: 404
+    });
+    const mountedRequest = createEffectBffMountedRequest(request, options.prefix);
+    const effectContext = createEffectBffDispatchContext(request, mountedRequest, options);
+    try {
+        const response = await options.runWithEffectContext(effectContext, ()=>handler(mountedRequest, effectContext));
+        if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return Response instance.');
+        return new Response(response.body, response);
+    } catch (error) {
+        if (error instanceof Response) return new Response(error.body, error);
+        if (options.onError) {
+            const errorResponse = await options.onError(error, effectContext);
+            if (errorResponse instanceof Response) return errorResponse;
+        }
+        return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error);
+    }
+}
+exports.dispatchEffectBffRequestWithContext = __webpack_exports__.dispatchEffectBffRequestWithContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "dispatchEffectBffRequestWithContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/edge.js

@@ -1,7 +1,10 @@
 "use strict";
 var __webpack_modules__ = {
-    "../safe-failure" (module) {
-        module.exports = require("../safe-failure.js");
+    "./backend-federation" (module) {
+        module.exports = require("./backend-federation.js");
+    },
+    "./dispatch" (module) {
+        module.exports = require("./dispatch.js");
     },
     "./edge-context" (module) {
         module.exports = require("./edge-context.js");
@@ -63,85 +66,39 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _safe_failure__rspack_import_0 = __webpack_require__("../safe-failure");
+    var _dispatch__rspack_import_0 = __webpack_require__("./dispatch");
     var _edge_context__rspack_import_1 = __webpack_require__("./edge-context");
     var _module__rspack_import_2 = __webpack_require__("./module");
-    var _operation_context__rspack_import_3 = __webpack_require__("./operation-context");
+    var _backend_federation__rspack_import_3 = __webpack_require__("./backend-federation");
     var _handler__rspack_import_4 = __webpack_require__("./handler");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _handler__rspack_import_4)if ([
-        "runWithEffectContext",
-        "useEffectContext",
-        "default",
+        "createBackendFederationLoadEntryPlugin",
         "useOperationContext",
+        "BACKEND_FEDERATION_MANIFEST_FILE",
         "createEffectOperationContext",
+        "loadBackendFederatedEffectApi",
+        "BACKEND_FEDERATION_CONTRACT_VERSION",
+        "createEffectBffEdgeHandler",
+        "runWithEffectContext",
+        "BACKEND_FEDERATION_EFFECT_EXPOSE",
+        "useEffectContext",
         "dispatchEffectBffRequest",
+        "default",
+        "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
         "createEffectBffTestHandler",
-        "createEffectBffEdgeHandler"
+        "createBackendFederationRuntime",
+        "createEffectBffEdgeDispatcher"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    function normalizePrefix(prefix) {
-        if (!prefix || '/' === prefix) return '';
-        return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-    }
-    function removePrefixFromPath(pathname, prefix) {
-        const normalized = normalizePrefix(prefix);
-        if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
-        const sliced = pathname.slice(normalized.length);
-        return sliced.startsWith('/') ? sliced : `/${sliced}`;
-    }
-    function matchesPrefix(pathname, prefix) {
-        const normalized = normalizePrefix(prefix);
-        return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
-    }
-    function createRequestForMountedPrefix(req, prefix) {
-        const url = new URL(req.url);
-        const nextPath = removePrefixFromPath(url.pathname, prefix);
-        if (nextPath === url.pathname) return req;
-        url.pathname = nextPath;
-        return new Request(url, req);
-    }
-    function createEdgeEffectContext(originalRequest, effectRequest, options) {
-        const originalPath = options.path || new URL(originalRequest.url).pathname;
-        const method = options.method || originalRequest.method;
-        return {
-            request: effectRequest,
-            env: options.env || {},
-            path: originalPath,
-            method,
-            operationContext: (0, _operation_context__rspack_import_3.createEffectOperationContext)({
-                request: effectRequest,
-                env: options.env || {},
-                path: originalPath,
-                method
-            })
-        };
-    }
-    function createRuntimeErrorResponse(error) {
-        return (0, _safe_failure__rspack_import_0.createSafeFailureResponse)(error);
-    }
+    var _operation_context__rspack_import_5 = __webpack_require__("./operation-context");
     async function dispatchEffectBffRequest(handler, request, options = {}) {
-        const requestPathname = new URL(request.url).pathname;
-        if (!matchesPrefix(requestPathname, options.prefix)) return new Response(null, {
-            status: 404
+        return (0, _dispatch__rspack_import_0.dispatchEffectBffRequestWithContext)(handler, request, {
+            ...options,
+            runWithEffectContext: _edge_context__rspack_import_1.runWithEffectContext
         });
-        const effectRequest = createRequestForMountedPrefix(request, options.prefix);
-        const effectContext = createEdgeEffectContext(request, effectRequest, options);
-        try {
-            const response = await (0, _edge_context__rspack_import_1.runWithEffectContext)(effectContext, ()=>handler.length > 1 ? handler(effectRequest, effectContext) : handler(effectRequest));
-            if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return a Response instance.');
-            return new Response(response.body, response);
-        } catch (error) {
-            if (error instanceof Response) return new Response(error.body, error);
-            if (options.onError) {
-                const errorResponse = await options.onError(error, effectContext);
-                if (errorResponse instanceof Response) return errorResponse;
-            }
-            return createRuntimeErrorResponse(error);
-        }
     }
-    const createEffectBffTestHandler = createEffectBffEdgeHandler;
-    async function createEffectBffEdgeHandler(options) {
+    async function createEffectBffEdgeDispatcher(options) {
         const loaded = await (0, _module__rspack_import_2.resolveEffectBffModuleHandler)(options.module, {
             openapi: options.openapi,
             dataPlatform: options.dataPlatform,
@@ -149,7 +106,7 @@ var __webpack_exports__ = {};
         });
         if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export defineEffectBff(...) or a { api, layer } HttpApi module.');
         return {
-            handler: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
+            dispatch: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
                     ...dispatchOptions,
                     prefix: options.prefix,
                     onError: options.onError
@@ -159,10 +116,26 @@ var __webpack_exports__ = {};
             }
         };
     }
+    const createEffectBffTestHandler = createEffectBffEdgeHandler;
+    async function createEffectBffEdgeHandler(options) {
+        const dispatcher = await createEffectBffEdgeDispatcher(options);
+        return {
+            handler: dispatcher.dispatch,
+            dispose: dispatcher.dispose
+        };
+    }
     __webpack_require__.d(__webpack_exports__, {
+        BACKEND_FEDERATION_CONTRACT_VERSION: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_CONTRACT_VERSION,
+        BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_EFFECT_EXPOSE,
+        BACKEND_FEDERATION_MANIFEST_FILE: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_MANIFEST_FILE,
+        BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>_backend_federation__rspack_import_3.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        createBackendFederationLoadEntryPlugin: ()=>_backend_federation__rspack_import_3.createBackendFederationLoadEntryPlugin,
+        createBackendFederationRuntime: ()=>_backend_federation__rspack_import_3.createBackendFederationRuntime,
+        createEffectBffEdgeDispatcher: ()=>createEffectBffEdgeDispatcher,
         createEffectBffEdgeHandler: ()=>createEffectBffEdgeHandler,
-        createEffectOperationContext: ()=>_operation_context__rspack_import_3.createEffectOperationContext,
+        createEffectOperationContext: ()=>_operation_context__rspack_import_5.createEffectOperationContext,
         dispatchEffectBffRequest: ()=>dispatchEffectBffRequest,
+        loadBackendFederatedEffectApi: ()=>_backend_federation__rspack_import_3.loadBackendFederatedEffectApi,
         runWithEffectContext: ()=>_edge_context__rspack_import_1.runWithEffectContext,
         useEffectContext: ()=>_edge_context__rspack_import_1.useEffectContext,
         useOperationContext: ()=>_edge_context__rspack_import_1.useOperationContext
@@ -170,18 +143,34 @@ var __webpack_exports__ = {};
         createEffectBffTestHandler: createEffectBffTestHandler
     });
 })();
+exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
+exports.BACKEND_FEDERATION_EFFECT_EXPOSE = __webpack_exports__.BACKEND_FEDERATION_EFFECT_EXPOSE;
+exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_FILE;
+exports.BACKEND_FEDERATION_NODE_ADAPTER_VERSION = __webpack_exports__.BACKEND_FEDERATION_NODE_ADAPTER_VERSION;
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
+exports.createEffectBffEdgeDispatcher = __webpack_exports__.createEffectBffEdgeDispatcher;
 exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
 exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
 exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
 exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
 exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
 exports.useEffectContext = __webpack_exports__.useEffectContext;
 exports.useOperationContext = __webpack_exports__.useOperationContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_CONTRACT_VERSION",
+    "BACKEND_FEDERATION_EFFECT_EXPOSE",
+    "BACKEND_FEDERATION_MANIFEST_FILE",
+    "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
+    "createBackendFederationLoadEntryPlugin",
+    "createBackendFederationRuntime",
+    "createEffectBffEdgeDispatcher",
     "createEffectBffEdgeHandler",
     "createEffectBffTestHandler",
     "createEffectOperationContext",
     "dispatchEffectBffRequest",
+    "loadBackendFederatedEffectApi",
     "runWithEffectContext",
     "useEffectContext",
     "useOperationContext"

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

@@ -30,15 +30,13 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     collectEffectEndpoints: ()=>collectEffectEndpoints,
     createEffectEndpointContractHash: ()=>createEffectEndpointContractHash,
-    createEffectOperationContractSource: ()=>createEffectOperationContractSource,
     ensureLeadingSlash: ()=>ensureLeadingSlash,
     extractHttpApiFromModule: ()=>extractHttpApiFromModule,
-    getEffectRoutePath: ()=>getEffectRoutePath,
     normalizeEffectPrefix: ()=>normalizeEffectPrefix,
-    resolveEffectApiId: ()=>resolveEffectApiId,
     toOperationContractSources: ()=>toOperationContractSources
 });
 const bff_core_namespaceObject = require("@modern-js/bff-core");
+const external_entry_shape_js_namespaceObject = require("./entry-shape.js");
 function ensureLeadingSlash(pathname) {
     return pathname.startsWith('/') ? pathname : `/${pathname}`;
 }
@@ -88,41 +86,29 @@ function createEffectOperationContractSource(endpoint) {
         routePath: endpoint.routePath
     };
 }
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
 async function extractHttpApiFromModule(mod, isHttpApi) {
-    if (!isRecord(mod)) return null;
-    if (isHttpApi(mod.api)) return mod.api;
-    const entry = mod.default;
-    if (isRecord(entry) && isHttpApi(entry.api)) return entry.api;
-    if ('function' == typeof entry && 0 === entry.length) {
-        const output = await entry();
-        if (isRecord(output) && isHttpApi(output.api)) return output.api;
-    }
-    return null;
+    const facts = (0, external_entry_shape_js_namespaceObject.classifyEffectBffEntryModule)(mod, {
+        isRequestHandler: (value)=>'function' == typeof value,
+        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;
 }
 function createEffectEndpointContractHash(endpoint, requestId) {
     return (0, bff_core_namespaceObject.createOperationContractHash)(createEffectOperationContractSource(endpoint), requestId);
 }
 exports.collectEffectEndpoints = __webpack_exports__.collectEffectEndpoints;
 exports.createEffectEndpointContractHash = __webpack_exports__.createEffectEndpointContractHash;
-exports.createEffectOperationContractSource = __webpack_exports__.createEffectOperationContractSource;
 exports.ensureLeadingSlash = __webpack_exports__.ensureLeadingSlash;
 exports.extractHttpApiFromModule = __webpack_exports__.extractHttpApiFromModule;
-exports.getEffectRoutePath = __webpack_exports__.getEffectRoutePath;
 exports.normalizeEffectPrefix = __webpack_exports__.normalizeEffectPrefix;
-exports.resolveEffectApiId = __webpack_exports__.resolveEffectApiId;
 exports.toOperationContractSources = __webpack_exports__.toOperationContractSources;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "collectEffectEndpoints",
     "createEffectEndpointContractHash",
-    "createEffectOperationContractSource",
     "ensureLeadingSlash",
     "extractHttpApiFromModule",
-    "getEffectRoutePath",
     "normalizeEffectPrefix",
-    "resolveEffectApiId",
     "toOperationContractSources"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -0,0 +1,84 @@
+"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__);
+const EFFECT_VALIDATOR_AWARE_FACTORY = Symbol.for('modernjs.effect.validatorAware');
+function isValidatorAwareHandlerFactory(factory) {
+    return Boolean('function' == typeof factory && factory[EFFECT_VALIDATOR_AWARE_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) {
+    return 'object' == typeof value && null !== value;
+}
+function classifyEffectBffEntryModule(value, predicates) {
+    if (!isEffectEntryRecord(value)) return null;
+    const rootModule = value;
+    if (predicates.isRequestHandler(rootModule.handler)) return createEntryShapeFacts(rootModule, predicates, '`handler` export');
+    const defaultEntry = rootModule.default;
+    if (predicates.isRequestHandler(defaultEntry)) return createEntryShapeFacts(rootModule, predicates, 'default request handler');
+    const module = isEffectEntryRecord(defaultEntry) ? {
+        ...rootModule,
+        ...defaultEntry
+    } : rootModule;
+    if (predicates.isRequestHandler(module.handler)) return createEntryShapeFacts(module, predicates, '`handler` export');
+    return createEntryShapeFacts(module, predicates);
+}
+function createEntryShapeFacts(module, predicates, legacyShape) {
+    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,
+        createHandler,
+        createHandlerValidatorAware: void 0 !== createHandler && predicates.isValidatorAwareHandlerFactory(createHandler),
+        api,
+        layer: module.layer,
+        hasRuntimeLayer
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    classifyEffectBffEntryModule: ()=>classifyEffectBffEntryModule,
+    isValidatorAwareHandlerFactory: ()=>isValidatorAwareHandlerFactory
+}, {
+    EFFECT_VALIDATOR_AWARE_FACTORY: EFFECT_VALIDATOR_AWARE_FACTORY,
+    strictEffectApproachMessage: strictEffectApproachMessage
+});
+exports.EFFECT_VALIDATOR_AWARE_FACTORY = __webpack_exports__.EFFECT_VALIDATOR_AWARE_FACTORY;
+exports.classifyEffectBffEntryModule = __webpack_exports__.classifyEffectBffEntryModule;
+exports.isValidatorAwareHandlerFactory = __webpack_exports__.isValidatorAwareHandlerFactory;
+exports.strictEffectApproachMessage = __webpack_exports__.strictEffectApproachMessage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EFFECT_VALIDATOR_AWARE_FACTORY",
+    "classifyEffectBffEntryModule",
+    "isValidatorAwareHandlerFactory",
+    "strictEffectApproachMessage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});