@bleedingdev/modern-js-bff-effect 3.8.3-ultramodern.2

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

@@ -0,0 +1,354 @@
+"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__, {
+    Config: ()=>Config_namespaceObject,
+    Cookies: ()=>http_namespaceObject.Cookies,
+    Effect: ()=>Effect_namespaceObject,
+    Etag: ()=>http_namespaceObject.Etag,
+    FetchHttpClient: ()=>http_namespaceObject.FetchHttpClient,
+    FindMyWay: ()=>http_namespaceObject.FindMyWay,
+    Headers: ()=>http_namespaceObject.Headers,
+    HttpApi: ()=>httpapi_namespaceObject.HttpApi,
+    HttpApiBuilder: ()=>httpapi_namespaceObject.HttpApiBuilder,
+    HttpApiClient: ()=>httpapi_namespaceObject.HttpApiClient,
+    HttpApiEndpoint: ()=>httpapi_namespaceObject.HttpApiEndpoint,
+    HttpApiError: ()=>httpapi_namespaceObject.HttpApiError,
+    HttpApiGroup: ()=>httpapi_namespaceObject.HttpApiGroup,
+    HttpApiMiddleware: ()=>httpapi_namespaceObject.HttpApiMiddleware,
+    HttpApiSchema: ()=>httpapi_namespaceObject.HttpApiSchema,
+    HttpApiSecurity: ()=>httpapi_namespaceObject.HttpApiSecurity,
+    HttpApiTest: ()=>httpapi_namespaceObject.HttpApiTest,
+    HttpBody: ()=>http_namespaceObject.HttpBody,
+    HttpClient: ()=>http_namespaceObject.HttpClient,
+    HttpClientError: ()=>http_namespaceObject.HttpClientError,
+    HttpClientRequest: ()=>http_namespaceObject.HttpClientRequest,
+    HttpClientResponse: ()=>http_namespaceObject.HttpClientResponse,
+    HttpEffect: ()=>http_namespaceObject.HttpEffect,
+    HttpIncomingMessage: ()=>http_namespaceObject.HttpIncomingMessage,
+    HttpMethod: ()=>http_namespaceObject.HttpMethod,
+    HttpMiddleware: ()=>http_namespaceObject.HttpMiddleware,
+    HttpPlatform: ()=>http_namespaceObject.HttpPlatform,
+    HttpRouter: ()=>http_namespaceObject.HttpRouter,
+    HttpServer: ()=>http_namespaceObject.HttpServer,
+    HttpServerError: ()=>http_namespaceObject.HttpServerError,
+    HttpServerRequest: ()=>http_namespaceObject.HttpServerRequest,
+    HttpServerRespondable: ()=>http_namespaceObject.HttpServerRespondable,
+    HttpServerResponse: ()=>http_namespaceObject.HttpServerResponse,
+    HttpStaticServer: ()=>http_namespaceObject.HttpStaticServer,
+    HttpStatus: ()=>http_namespaceObject.HttpStatus,
+    HttpTraceContext: ()=>http_namespaceObject.HttpTraceContext,
+    Layer: ()=>Layer_namespaceObject,
+    Multipart: ()=>http_namespaceObject.Multipart,
+    MultipartParser: ()=>http_namespaceObject.MultipartParser,
+    OpenApi: ()=>httpapi_namespaceObject.OpenApi,
+    Option: ()=>Option_namespaceObject,
+    Rpc: ()=>rpc_namespaceObject.Rpc,
+    RpcClient: ()=>rpc_namespaceObject.RpcClient,
+    RpcClientError: ()=>rpc_namespaceObject.RpcClientError,
+    RpcGroup: ()=>rpc_namespaceObject.RpcGroup,
+    RpcMessage: ()=>rpc_namespaceObject.RpcMessage,
+    RpcMiddleware: ()=>rpc_namespaceObject.RpcMiddleware,
+    RpcSchema: ()=>rpc_namespaceObject.RpcSchema,
+    RpcSerialization: ()=>rpc_namespaceObject.RpcSerialization,
+    RpcServer: ()=>rpc_namespaceObject.RpcServer,
+    RpcTest: ()=>rpc_namespaceObject.RpcTest,
+    RpcWorker: ()=>rpc_namespaceObject.RpcWorker,
+    Schema: ()=>Schema_namespaceObject,
+    Template: ()=>http_namespaceObject.Template,
+    Url: ()=>http_namespaceObject.Url,
+    UrlParams: ()=>http_namespaceObject.UrlParams,
+    Utils: ()=>rpc_namespaceObject.Utils,
+    createEffectBffEdgeDispatcher: ()=>createEffectBffEdgeDispatcher,
+    createEffectBffEdgeHandler: ()=>createEffectBffEdgeHandler,
+    createEffectBffTestHandler: ()=>createEffectBffTestHandler,
+    createEffectOperationContext: ()=>external_operation_context_js_namespaceObject.createEffectOperationContext,
+    createHttpApiHandler: ()=>external_handler_js_namespaceObject.createHttpApiHandler,
+    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
+});
+const cross_project_policy_namespaceObject = require("@modern-js/bff-core/security/cross-project-policy");
+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");
+const http_namespaceObject = require("effect/unstable/http");
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const rpc_namespaceObject = require("effect/unstable/rpc");
+const external_handler_js_namespaceObject = require("./handler.js");
+const external_operation_context_js_namespaceObject = require("./operation-context.js");
+const NORMALIZED_POLICY_BOOLEAN_FIELDS = [
+    'enabled',
+    'requireEnvelope',
+    'requireOperationContext',
+    'requireOperationContextDetails',
+    'requireOperationSchemaHash',
+    'requireOperationVersion',
+    'allowUnknownOperations'
+];
+function assertNormalizedCrossProjectPolicy(policy) {
+    if (void 0 === policy) return;
+    if (!policy || 'object' != typeof policy || Array.isArray(policy)) throw new Error('[BFF][Effect] Edge cross-project policy must be a normalized object.');
+    for (const field of NORMALIZED_POLICY_BOOLEAN_FIELDS)if ('boolean' != typeof policy[field]) throw new Error(`[BFF][Effect] Edge cross-project policy requires boolean ${field}.`);
+    if (!policy.expectedOperationContracts || 'object' != typeof policy.expectedOperationContracts || Array.isArray(policy.expectedOperationContracts)) throw new Error('[BFF][Effect] Edge cross-project policy requires expectedOperationContracts object.');
+}
+function restoreEffectBffMountPath(request, prefix) {
+    const pathname = new URL(request.url).pathname;
+    if (!prefix || '/' === prefix) return pathname;
+    const normalizedPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return '/' === pathname ? normalizedPrefix : `${normalizedPrefix}${pathname}`;
+}
+async function dispatchEffectBffRequest(handler, request, options = {}) {
+    return (0, external_dispatch_js_namespaceObject.dispatchEffectBffRequestWithContext)(handler, request, {
+        ...options,
+        runWithEffectContext: external_edge_context_js_namespaceObject.runWithEffectContext
+    });
+}
+async function createEffectBffEdgeDispatcher(options) {
+    const crossProjectPolicy = options.crossProjectPolicy;
+    assertNormalizedCrossProjectPolicy(crossProjectPolicy);
+    const loaded = await (0, external_module_js_namespaceObject.resolveEffectBffModuleHandler)(options.module, {
+        openapi: options.openapi,
+        dataPlatform: options.dataPlatform,
+        validateRequest: crossProjectPolicy?.enabled === true ? (request)=>{
+            const pathname = new URL(request.url).pathname;
+            const observedRequest = (0, cross_project_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);
+            if (!violation) return null;
+            return new Response(JSON.stringify({
+                code: violation.code,
+                reason: violation.reason,
+                message: violation.message
+            }), {
+                status: violation.status,
+                headers: {
+                    'content-type': 'application/json; charset=utf-8'
+                }
+            });
+        } : void 0,
+        onWarning: options.onWarning
+    });
+    if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export defineEffectBff(...) or a { api, layer } HttpApi module.');
+    const retiredError = new Error('[BFF][Effect] Edge dispatcher is disposing or has been disposed.');
+    let acceptingRequests = true;
+    let activeDispatches = 0;
+    let resolveDrain;
+    let disposePromise;
+    return {
+        dispatch: (request, dispatchOptions = {})=>{
+            if (!acceptingRequests) return Promise.reject(retiredError);
+            activeDispatches += 1;
+            return dispatchEffectBffRequest(loaded.handler, request, {
+                ...dispatchOptions,
+                prefix: options.prefix,
+                onError: options.onError
+            }).finally(()=>{
+                activeDispatches -= 1;
+                if (0 === activeDispatches) {
+                    resolveDrain?.();
+                    resolveDrain = void 0;
+                }
+            });
+        },
+        dispose: ()=>{
+            disposePromise ??= (async ()=>{
+                acceptingRequests = false;
+                if (activeDispatches > 0) await new Promise((resolve)=>{
+                    resolveDrain = resolve;
+                });
+                await loaded.dispose?.();
+            })();
+            return disposePromise;
+        }
+    };
+}
+const createEffectBffTestHandler = createEffectBffEdgeHandler;
+async function createEffectBffEdgeHandler(options) {
+    const dispatcher = await createEffectBffEdgeDispatcher(options);
+    return {
+        handler: dispatcher.dispatch,
+        dispose: dispatcher.dispose
+    };
+}
+exports.Config = __webpack_exports__.Config;
+exports.Cookies = __webpack_exports__.Cookies;
+exports.Effect = __webpack_exports__.Effect;
+exports.Etag = __webpack_exports__.Etag;
+exports.FetchHttpClient = __webpack_exports__.FetchHttpClient;
+exports.FindMyWay = __webpack_exports__.FindMyWay;
+exports.Headers = __webpack_exports__.Headers;
+exports.HttpApi = __webpack_exports__.HttpApi;
+exports.HttpApiBuilder = __webpack_exports__.HttpApiBuilder;
+exports.HttpApiClient = __webpack_exports__.HttpApiClient;
+exports.HttpApiEndpoint = __webpack_exports__.HttpApiEndpoint;
+exports.HttpApiError = __webpack_exports__.HttpApiError;
+exports.HttpApiGroup = __webpack_exports__.HttpApiGroup;
+exports.HttpApiMiddleware = __webpack_exports__.HttpApiMiddleware;
+exports.HttpApiSchema = __webpack_exports__.HttpApiSchema;
+exports.HttpApiSecurity = __webpack_exports__.HttpApiSecurity;
+exports.HttpApiTest = __webpack_exports__.HttpApiTest;
+exports.HttpBody = __webpack_exports__.HttpBody;
+exports.HttpClient = __webpack_exports__.HttpClient;
+exports.HttpClientError = __webpack_exports__.HttpClientError;
+exports.HttpClientRequest = __webpack_exports__.HttpClientRequest;
+exports.HttpClientResponse = __webpack_exports__.HttpClientResponse;
+exports.HttpEffect = __webpack_exports__.HttpEffect;
+exports.HttpIncomingMessage = __webpack_exports__.HttpIncomingMessage;
+exports.HttpMethod = __webpack_exports__.HttpMethod;
+exports.HttpMiddleware = __webpack_exports__.HttpMiddleware;
+exports.HttpPlatform = __webpack_exports__.HttpPlatform;
+exports.HttpRouter = __webpack_exports__.HttpRouter;
+exports.HttpServer = __webpack_exports__.HttpServer;
+exports.HttpServerError = __webpack_exports__.HttpServerError;
+exports.HttpServerRequest = __webpack_exports__.HttpServerRequest;
+exports.HttpServerRespondable = __webpack_exports__.HttpServerRespondable;
+exports.HttpServerResponse = __webpack_exports__.HttpServerResponse;
+exports.HttpStaticServer = __webpack_exports__.HttpStaticServer;
+exports.HttpStatus = __webpack_exports__.HttpStatus;
+exports.HttpTraceContext = __webpack_exports__.HttpTraceContext;
+exports.Layer = __webpack_exports__.Layer;
+exports.Multipart = __webpack_exports__.Multipart;
+exports.MultipartParser = __webpack_exports__.MultipartParser;
+exports.OpenApi = __webpack_exports__.OpenApi;
+exports.Option = __webpack_exports__.Option;
+exports.Rpc = __webpack_exports__.Rpc;
+exports.RpcClient = __webpack_exports__.RpcClient;
+exports.RpcClientError = __webpack_exports__.RpcClientError;
+exports.RpcGroup = __webpack_exports__.RpcGroup;
+exports.RpcMessage = __webpack_exports__.RpcMessage;
+exports.RpcMiddleware = __webpack_exports__.RpcMiddleware;
+exports.RpcSchema = __webpack_exports__.RpcSchema;
+exports.RpcSerialization = __webpack_exports__.RpcSerialization;
+exports.RpcServer = __webpack_exports__.RpcServer;
+exports.RpcTest = __webpack_exports__.RpcTest;
+exports.RpcWorker = __webpack_exports__.RpcWorker;
+exports.Schema = __webpack_exports__.Schema;
+exports.Template = __webpack_exports__.Template;
+exports.Url = __webpack_exports__.Url;
+exports.UrlParams = __webpack_exports__.UrlParams;
+exports.Utils = __webpack_exports__.Utils;
+exports.createEffectBffEdgeDispatcher = __webpack_exports__.createEffectBffEdgeDispatcher;
+exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
+exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.createHttpApiHandler = __webpack_exports__.createHttpApiHandler;
+exports.defineEffectBff = __webpack_exports__.defineEffectBff;
+exports.defineEffectRpcBff = __webpack_exports__.defineEffectRpcBff;
+exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
+exports.useEffectContext = __webpack_exports__.useEffectContext;
+exports.useOperationContext = __webpack_exports__.useOperationContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Config",
+    "Cookies",
+    "Effect",
+    "Etag",
+    "FetchHttpClient",
+    "FindMyWay",
+    "Headers",
+    "HttpApi",
+    "HttpApiBuilder",
+    "HttpApiClient",
+    "HttpApiEndpoint",
+    "HttpApiError",
+    "HttpApiGroup",
+    "HttpApiMiddleware",
+    "HttpApiSchema",
+    "HttpApiSecurity",
+    "HttpApiTest",
+    "HttpBody",
+    "HttpClient",
+    "HttpClientError",
+    "HttpClientRequest",
+    "HttpClientResponse",
+    "HttpEffect",
+    "HttpIncomingMessage",
+    "HttpMethod",
+    "HttpMiddleware",
+    "HttpPlatform",
+    "HttpRouter",
+    "HttpServer",
+    "HttpServerError",
+    "HttpServerRequest",
+    "HttpServerRespondable",
+    "HttpServerResponse",
+    "HttpStaticServer",
+    "HttpStatus",
+    "HttpTraceContext",
+    "Layer",
+    "Multipart",
+    "MultipartParser",
+    "OpenApi",
+    "Option",
+    "Rpc",
+    "RpcClient",
+    "RpcClientError",
+    "RpcGroup",
+    "RpcMessage",
+    "RpcMiddleware",
+    "RpcSchema",
+    "RpcSerialization",
+    "RpcServer",
+    "RpcTest",
+    "RpcWorker",
+    "Schema",
+    "Template",
+    "Url",
+    "UrlParams",
+    "Utils",
+    "createEffectBffEdgeDispatcher",
+    "createEffectBffEdgeHandler",
+    "createEffectBffTestHandler",
+    "createEffectOperationContext",
+    "createHttpApiHandler",
+    "defineEffectBff",
+    "defineEffectRpcBff",
+    "dispatchEffectBffRequest",
+    "runWithEffectContext",
+    "useEffectContext",
+    "useOperationContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/edge.js

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_modules__ = {
+    "./edge-dispatcher" (module) {
+        module.exports = require("./edge-dispatcher.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 _edge_dispatcher__rspack_import_0 = __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];
+    __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/effect/endpoint-contracts.js

@@ -0,0 +1,121 @@
+"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__, {
+    collectEffectEndpoints: ()=>collectEffectEndpoints,
+    createEffectEndpointContractHash: ()=>createEffectEndpointContractHash,
+    ensureLeadingSlash: ()=>ensureLeadingSlash,
+    extractHttpApiFromModule: ()=>extractHttpApiFromModule,
+    normalizeEffectPrefix: ()=>normalizeEffectPrefix,
+    toOperationContractSources: ()=>toOperationContractSources
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+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) {
+    return pathname.startsWith('/') ? pathname : `/${pathname}`;
+}
+function normalizeEffectPrefix(prefix) {
+    if ('/' === prefix) return '';
+    return ensureLeadingSlash(prefix || '/api');
+}
+function getEffectRoutePath(prefix, endpointPath) {
+    const normalizedPrefix = normalizeEffectPrefix(prefix);
+    const normalizedEndpointPath = ensureLeadingSlash(endpointPath);
+    const finalEndpointPath = '/' === normalizedEndpointPath ? '' : endpointPath;
+    if (!normalizedPrefix && !finalEndpointPath) return '/';
+    return `${normalizedPrefix}${finalEndpointPath || ''}`;
+}
+function resolveEffectApiId(api) {
+    const fallback = 'EffectHttpApi';
+    if ('identifier' in api && 'string' == typeof api.identifier && api.identifier) return api.identifier;
+    return fallback;
+}
+function collectEffectEndpoints(reflect, api, prefix) {
+    const endpoints = [];
+    const apiId = resolveEffectApiId(api);
+    reflect(api, {
+        onGroup: ()=>{},
+        onEndpoint: ({ group, endpoint })=>{
+            endpoints.push({
+                apiId,
+                groupName: String(group.identifier),
+                endpointName: resolveEffectEndpointName(endpoint),
+                method: String(endpoint.method).toUpperCase(),
+                routePath: getEffectRoutePath(prefix, String(endpoint.path))
+            });
+        }
+    });
+    return endpoints.sort((a, b)=>{
+        if (a.groupName === b.groupName) return a.endpointName.localeCompare(b.endpointName);
+        return a.groupName.localeCompare(b.groupName);
+    });
+}
+function toOperationContractSources(endpoints) {
+    return endpoints.map(createEffectOperationContractSource);
+}
+function createEffectOperationContractSource(endpoint) {
+    return {
+        name: endpoint.endpointName,
+        httpMethod: endpoint.method,
+        routePath: endpoint.routePath
+    };
+}
+async function extractHttpApiFromModule(mod, isHttpApi) {
+    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.ensureLeadingSlash = __webpack_exports__.ensureLeadingSlash;
+exports.extractHttpApiFromModule = __webpack_exports__.extractHttpApiFromModule;
+exports.normalizeEffectPrefix = __webpack_exports__.normalizeEffectPrefix;
+exports.toOperationContractSources = __webpack_exports__.toOperationContractSources;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectEffectEndpoints",
+    "createEffectEndpointContractHash",
+    "ensureLeadingSlash",
+    "extractHttpApiFromModule",
+    "normalizeEffectPrefix",
+    "toOperationContractSources"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,31 @@
+"use strict";
+"use strict";
+var __webpack_modules__ = {
+    "./src/effect/entry-shape-registry.cjs" (module) {
+        const validatorAwareHandlerFactories = new WeakSet();
+        module.exports = {
+            register (factory) {
+                validatorAwareHandlerFactories.add(factory);
+                return factory;
+            },
+            is (factory) {
+                return 'function' == typeof factory && validatorAwareHandlerFactories.has(factory);
+            }
+        };
+    }
+};
+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;
+}
+var __webpack_exports__ = __webpack_require__("./src/effect/entry-shape-registry.cjs");
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,113 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function createLocalValidatorAwareHandlerFactoryRegistry() {
+    const factories = new WeakSet();
+    return {
+        register (factory) {
+            factories.add(factory);
+            return factory;
+        },
+        is (factory) {
+            return 'function' == typeof factory && factories.has(factory);
+        }
+    };
+}
+function loadNodeValidatorAwareHandlerFactoryRegistry() {
+    const moduleUrl = __rslib_import_meta_url__;
+    if ('string' != typeof moduleUrl || !moduleUrl.startsWith('file:')) return createLocalValidatorAwareHandlerFactoryRegistry();
+    const moduleBuiltin = process.getBuiltinModule('node:module');
+    try {
+        return moduleBuiltin.createRequire(moduleUrl)("#effect-entry-shape-registry");
+    } catch (error) {
+        if (null !== error && 'object' == typeof error && 'code' in error && 'MODULE_NOT_FOUND' === error.code) return createLocalValidatorAwareHandlerFactoryRegistry();
+        throw error;
+    }
+}
+const validatorAwareHandlerFactoryRegistry = loadNodeValidatorAwareHandlerFactoryRegistry();
+function registerValidatorAwareHandlerFactory(factory) {
+    return validatorAwareHandlerFactoryRegistry.register(factory);
+}
+function isValidatorAwareHandlerFactory(factory) {
+    return validatorAwareHandlerFactoryRegistry.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) {
+    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,
+    registerValidatorAwareHandlerFactory: ()=>registerValidatorAwareHandlerFactory
+}, {
+    strictEffectApproachMessage: strictEffectApproachMessage
+});
+exports.classifyEffectBffEntryModule = __webpack_exports__.classifyEffectBffEntryModule;
+exports.isValidatorAwareHandlerFactory = __webpack_exports__.isValidatorAwareHandlerFactory;
+exports.registerValidatorAwareHandlerFactory = __webpack_exports__.registerValidatorAwareHandlerFactory;
+exports.strictEffectApproachMessage = __webpack_exports__.strictEffectApproachMessage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "classifyEffectBffEntryModule",
+    "isValidatorAwareHandlerFactory",
+    "registerValidatorAwareHandlerFactory",
+    "strictEffectApproachMessage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});