@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

package/dist/cjs/runtime/effect/adapter/handler.js

@@ -0,0 +1,53 @@
+"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__, {
+    loadEffectAdapterHandlerFromModule: ()=>loadEffectAdapterHandlerFromModule
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const crossProjectServerPolicy_js_namespaceObject = require("../../../utils/crossProjectServerPolicy.js");
+const external_module_js_namespaceObject = require("../module.js");
+async function loadEffectAdapterHandlerFromModule(api, mod, crossProjectPolicy) {
+    const effectConfig = api.getServerConfig()?.bff?.effect;
+    return (0, external_module_js_namespaceObject.resolveEffectBffModuleHandler)(mod, {
+        openapi: effectConfig?.openapi,
+        dataPlatform: effectConfig?.dataPlatform,
+        validateRequest: (request)=>(0, crossProjectServerPolicy_js_namespaceObject.checkCrossProjectPolicyForRequest)(request, crossProjectPolicy),
+        onWarning: (message)=>{
+            utils_namespaceObject.logger.warn(message);
+        }
+    });
+}
+exports.loadEffectAdapterHandlerFromModule = __webpack_exports__.loadEffectAdapterHandlerFromModule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadEffectAdapterHandlerFromModule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1,14 +1,5 @@
 "use strict";
 var __webpack_require__ = {};
-(()=>{
-    __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)=>{
@@ -40,75 +31,16 @@ __webpack_require__.d(__webpack_exports__, {
     EffectAdapter: ()=>EffectAdapter
 });
 const utils_namespaceObject = require("@modern-js/utils");
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
-const crossProjectServerPolicy_js_namespaceObject = require("../../utils/crossProjectServerPolicy.js");
-const external_safe_failure_js_namespaceObject = require("../safe-failure.js");
+const constants_js_namespaceObject = require("./adapter/constants.js");
+const cross_project_policy_js_namespaceObject = require("./adapter/cross-project-policy.js");
+const entry_js_namespaceObject = require("./adapter/entry.js");
+const error_response_js_namespaceObject = require("./adapter/error-response.js");
+const handler_js_namespaceObject = require("./adapter/handler.js");
 const external_context_js_namespaceObject = require("./context.js");
 const external_dispatch_js_namespaceObject = require("./dispatch.js");
-const external_endpoint_contracts_js_namespaceObject = require("./endpoint-contracts.js");
-const external_module_js_namespaceObject = require("./module.js");
-const before = [
-    'custom-server-hook',
-    'custom-server-middleware',
-    'render'
-];
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-function resolveJsOrTsEntry(entryWithoutOrWithExt) {
-    const extension = external_path_default().extname(entryWithoutOrWithExt);
-    if (JS_OR_TS_EXTS.includes(extension)) return utils_namespaceObject.fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
-    return (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutOrWithExt}${ext}`));
-}
 class EffectAdapter {
     resolveEntryFile() {
-        const { appDirectory, apiDirectory } = this.api.getServerContext();
-        const bffConfig = this.api.getServerConfig()?.bff;
-        const configuredEntry = bffConfig?.effect?.entry;
-        if (configuredEntry) {
-            const entryWithoutExt = external_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_path_default().resolve(appDirectory || process.cwd(), configuredEntry);
-            return resolveJsOrTsEntry(entryWithoutExt);
-        }
-        const apiRoot = external_path_default().resolve(appDirectory || process.cwd(), apiDirectory || utils_namespaceObject.API_DIR);
-        return resolveJsOrTsEntry(external_path_default().resolve(apiRoot, 'index'));
-    }
-    async refreshCrossProjectPolicy(mod) {
-        let contractSources = [];
-        if (mod) try {
-            const api = await (0, external_endpoint_contracts_js_namespaceObject.extractHttpApiFromModule)(mod, httpapi_namespaceObject.HttpApi.isHttpApi);
-            if (api) {
-                const reflect = (apiValue, handlers)=>httpapi_namespaceObject.HttpApi.reflect(apiValue, {
-                        onGroup: handlers.onGroup ?? (()=>{}),
-                        onEndpoint: handlers.onEndpoint
-                    });
-                contractSources = (0, external_endpoint_contracts_js_namespaceObject.toOperationContractSources)((0, external_endpoint_contracts_js_namespaceObject.collectEffectEndpoints)(reflect, api, this.prefix));
-            }
-        } catch (error) {
-            utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to reflect HttpApi endpoints for the cross-project policy: ${String(error)}`);
-        }
-        const policy = (0, crossProjectServerPolicy_js_namespaceObject.resolveAdapterCrossProjectPolicy)(this.api, contractSources);
-        this.crossProjectPolicy = policy;
-        if (this.crossProjectPolicy?.enabled && 0 === contractSources.length) utils_namespaceObject.logger.warn('[BFF][Effect] Cross-project policy is enabled but no HttpApi endpoints could be reflected; operation-contract matching is disabled for this server (envelope and operation-context checks still apply).');
-    }
-    async loadEffectHandlerFromModule(mod) {
-        const effectConfig = this.api.getServerConfig()?.bff?.effect;
-        return (0, external_module_js_namespaceObject.resolveEffectBffModuleHandler)(mod, {
-            openapi: effectConfig?.openapi,
-            dataPlatform: effectConfig?.dataPlatform,
-            validateRequest: (request)=>(0, crossProjectServerPolicy_js_namespaceObject.checkCrossProjectPolicyForRequest)(request, this.crossProjectPolicy),
-            onWarning: (message)=>{
-                utils_namespaceObject.logger.warn(message);
-            }
-        });
+        return (0, entry_js_namespaceObject.resolveEffectAdapterEntryFile)(this.api);
     }
     async reloadHandler() {
         if (!this.isEffect) return;
@@ -134,8 +66,8 @@ class EffectAdapter {
             this.handler = null;
             return;
         }
-        await this.refreshCrossProjectPolicy(mod);
-        const loaded = await this.loadEffectHandlerFromModule(mod);
+        this.crossProjectPolicy = await (0, cross_project_policy_js_namespaceObject.resolveEffectAdapterCrossProjectPolicy)(this.api, this.prefix, mod);
+        const loaded = await (0, handler_js_namespaceObject.loadEffectAdapterHandlerFromModule)(this.api, mod, this.crossProjectPolicy);
         if (!loaded) {
             utils_namespaceObject.logger.warn(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
             this.handler = null;
@@ -149,48 +81,13 @@ class EffectAdapter {
         try {
             await this.dispose();
         } catch (error) {
-            utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to dispose previous handler: ${String(error)}`);
+            utils_namespaceObject.logger.warn(`[BFF][Effect] Failed dispose previous handler: ${String(error)}`);
         } finally{
             this.dispose = null;
         }
     }
-    async handleRuntimeError(error, c) {
-        try {
-            const serverConfig = this.api.getServerConfig();
-            const onErrorHandler = serverConfig?.onError;
-            if (onErrorHandler) {
-                const onErrorContext = this.ensureJsonContext(c);
-                const result = await onErrorHandler(error instanceof Error ? error : new Error(String(error)), onErrorContext);
-                if (result instanceof Response) return result;
-            } else utils_namespaceObject.logger.error(error);
-        } catch (configError) {
-            utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${configError}`);
-        }
-        return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error);
-    }
-    ensureJsonContext(c) {
-        const maybeJsonContext = c;
-        if ('function' == typeof maybeJsonContext.json) return c;
-        const headers = {
-            'content-type': 'application/json; charset=utf-8'
-        };
-        const withJson = Object.assign({}, c, {
-            json: (data, status = 200, extraHeaders)=>{
-                const responseHeaders = new Headers(headers);
-                if (extraHeaders) new Headers(extraHeaders).forEach((value, key)=>{
-                    responseHeaders.set(key, value);
-                });
-                return new Response(JSON.stringify(data), {
-                    status,
-                    headers: responseHeaders
-                });
-            }
-        });
-        return withJson;
-    }
     constructor(api){
         this.isEffect = true;
-        this.effectMiddleware = null;
         this.handler = null;
         this.dispose = null;
         this.prefix = '/api';
@@ -208,11 +105,11 @@ class EffectAdapter {
                 path: enableHandleWeb ? '*' : `${prefix}/*`,
                 method: 'all',
                 order: 'post',
-                before,
+                before: constants_js_namespaceObject.before,
                 handler: async (c, next)=>{
                     if (!this.handler) {
                         if (enableHandleWeb) return void await next();
-                        return this.handleRuntimeError(new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), c);
+                        return (0, error_response_js_namespaceObject.createEffectAdapterRuntimeErrorResponse)(this.api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), c);
                     }
                     const response = await (0, external_dispatch_js_namespaceObject.dispatchEffectBffRequestWithContext)(this.handler, c.req.raw, {
                         prefix,
@@ -220,7 +117,7 @@ class EffectAdapter {
                         path: c.req.path,
                         method: c.req.method,
                         runWithEffectContext: external_context_js_namespaceObject.runWithEffectContext,
-                        onError: (error)=>this.handleRuntimeError(error, c)
+                        onError: (error)=>(0, error_response_js_namespaceObject.createEffectAdapterRuntimeErrorResponse)(this.api, error, c)
                     });
                     if (404 === response.status && enableHandleWeb) return void await next();
                     return new Response(response.body, response);

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

@@ -0,0 +1,99 @@
+"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__, {
+    loadBackendFederationExpose: ()=>loadBackendFederationExpose
+});
+const external_utils_js_namespaceObject = require("./utils.js");
+function decodeDataUrl(url) {
+    const commaIndex = url.indexOf(',');
+    if (commaIndex < 0) throw new Error('[BFF][Effect] Invalid backend federation data URL entry.');
+    return decodeURIComponent(url.slice(commaIndex + 1));
+}
+async function readCommonJsEntrySource(remote) {
+    if (remote.entry.startsWith('data:')) return decodeDataUrl(remote.entry);
+    if (remote.entry.startsWith('http://') || remote.entry.startsWith('https://')) {
+        const response = await fetch(remote.entry);
+        if (!response.ok) throw new Error(`[BFF][Effect] Failed to load backend federation remote ${remote.name}: ${response.status}`);
+        return response.text();
+    }
+    throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} cannot load CommonJS entry ${remote.entry}.`);
+}
+function evaluateCommonJsEntry(remote, source) {
+    const module = {
+        exports: {}
+    };
+    const exports1 = module.exports;
+    const evaluate = new Function('module', 'exports', 'globalThis', source);
+    evaluate(module, exports1, globalThis);
+    const entry = module.exports.default ?? module.exports;
+    if (!(0, external_utils_js_namespaceObject.isRecord)(entry)) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must load object module.`);
+    return entry;
+}
+async function importModuleEntry(remote) {
+    const entry = await import(remote.entry);
+    return entry.default ?? entry;
+}
+async function resolvePluginEntry(remote, plugins) {
+    for (const plugin of plugins ?? []){
+        const loadEntry = plugin.loadEntry;
+        if ('function' != typeof loadEntry) continue;
+        const entry = await loadEntry({
+            remoteInfo: remote
+        });
+        if (entry) return entry;
+    }
+}
+async function loadBackendFederationEntry(remote, plugins) {
+    const pluginEntry = await resolvePluginEntry(remote, plugins);
+    if (pluginEntry) return pluginEntry;
+    if (remote.entryGlobalName) {
+        const globalEntry = globalThis[remote.entryGlobalName];
+        if ((0, external_utils_js_namespaceObject.isRecord)(globalEntry)) return globalEntry;
+    }
+    if ('module' === remote.type || remote.entry.startsWith('file:')) return importModuleEntry(remote);
+    return evaluateCommonJsEntry(remote, await readCommonJsEntrySource(remote));
+}
+async function loadBackendFederationExpose(remote, expose, options) {
+    const entry = await loadBackendFederationEntry(remote, options.plugins);
+    if ('function' == typeof entry.init) await entry.init({
+        hostName: options.hostName
+    });
+    if ('function' != typeof entry.get) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`);
+    const factory = await entry.get(expose);
+    if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)} must load factory function.`);
+    return factory();
+}
+exports.loadBackendFederationExpose = __webpack_exports__.loadBackendFederationExpose;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadBackendFederationExpose"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,57 @@
+"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__, {
+    loadBackendFederatedEffectApi: ()=>loadBackendFederatedEffectApi
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_runtime_js_namespaceObject = require("./runtime.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+async function loadBackendFederatedEffectApi(options) {
+    const remoteName = options.remote?.name ?? options.remoteName;
+    if (!remoteName) throw new Error('[BFF][Effect] Missing backend federation remote name.');
+    const runtime = options.runtime ?? (0, external_runtime_js_namespaceObject.createBackendFederationRuntime)(options);
+    const expose = options.expose ?? options.remote?.expose ?? universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
+    const remoteRequest = `${remoteName}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)}`;
+    const loaded = await runtime.loadRemote(remoteRequest);
+    if (!(0, external_utils_js_namespaceObject.isRecord)(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must load an object module.`);
+    const backendContract = loaded.backendFederationContract;
+    if (!(0, external_utils_js_namespaceObject.isRecord)(backendContract) || true !== backendContract.strictEffectApproach) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (strictEffectApproach: true).`);
+    if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
+    if ('string' == typeof backendContract.name && backendContract.name !== remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} metadata name mismatch: expected ${remoteName}, received ${backendContract.name}.`);
+    if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose api and runtime.`);
+    return loaded;
+}
+exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadBackendFederatedEffectApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function createBackendFederationLoadEntryPlugin(options) {
+    return {
+        name: 'modernjs-backend-federation-load-entry',
+        async loadEntry ({ remoteInfo }) {
+            return options.resolveEntry({
+                name: remoteInfo.name,
+                entry: remoteInfo.entry,
+                type: remoteInfo.type,
+                entryGlobalName: remoteInfo.entryGlobalName,
+                shareScope: remoteInfo.shareScope
+            });
+        }
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    createBackendFederationLoadEntryPlugin: ()=>createBackendFederationLoadEntryPlugin
+});
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBackendFederationLoadEntryPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/backend-federation/remotes.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__);
+function collectRemotes(options) {
+    const remotes = [
+        ...options.remotes ?? []
+    ];
+    if (options.remote) {
+        const existingIndex = remotes.findIndex((remote)=>remote.name === options.remote?.name);
+        if (existingIndex >= 0) remotes[existingIndex] = options.remote;
+        else remotes.push(options.remote);
+    }
+    return remotes;
+}
+__webpack_require__.d(__webpack_exports__, {
+    collectRemotes: ()=>collectRemotes
+});
+exports.collectRemotes = __webpack_exports__.collectRemotes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectRemotes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,64 @@
+"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__, {
+    createBackendFederationRuntime: ()=>createBackendFederationRuntime
+});
+const external_entry_js_namespaceObject = require("./entry.js");
+const external_remotes_js_namespaceObject = require("./remotes.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+function exposeForRemoteRequest(expose) {
+    return `./${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)}`;
+}
+function parseRemoteRequest(request) {
+    const [remoteName, ...exposeParts] = request.split('/');
+    if (!remoteName || 0 === exposeParts.length) throw new Error(`[BFF][Effect] Invalid backend federation request ${request}.`);
+    return {
+        remoteName,
+        expose: exposeForRemoteRequest(exposeParts.join('/'))
+    };
+}
+function createBackendFederationRuntime(options) {
+    const remotes = (0, external_remotes_js_namespaceObject.collectRemotes)(options);
+    return {
+        async loadRemote (request) {
+            const { remoteName, expose } = parseRemoteRequest(request);
+            const remote = remotes.find((candidate)=>candidate.name === remoteName);
+            if (!remote) throw new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`);
+            return (0, external_entry_js_namespaceObject.loadBackendFederationExpose)(remote, expose, options);
+        }
+    };
+}
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBackendFederationRuntime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+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/utils.js

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function normalizeExpose(expose) {
+    return expose.replace(/^\.\//u, '');
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+__webpack_require__.d(__webpack_exports__, {
+    isRecord: ()=>isRecord,
+    normalizeExpose: ()=>normalizeExpose
+});
+exports.isRecord = __webpack_exports__.isRecord;
+exports.normalizeExpose = __webpack_exports__.normalizeExpose;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isRecord",
+    "normalizeExpose"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});