@bleedingdev/modern-js-plugin-bff-extensions 3.8.3-ultramodern.2

package/dist/cjs/hono/bind-route-handlers.js

@@ -0,0 +1,76 @@
+"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__, {
+    bindHonoRouteHandlers: ()=>bindHonoRouteHandlers
+});
+const safe_failure_namespaceObject = require("@modern-js/runtime-extensions/safe-failure");
+const external_cross_project_policy_js_namespaceObject = require("./cross-project-policy.js");
+const bindHonoRouteHandlers = ({ handler, policy, routePath, onError, reportError })=>{
+    const handlers = Array.isArray(handler) ? handler : [
+        handler
+    ];
+    const [firstHandler, ...restHandlers] = handlers;
+    let routeHandlers = handler;
+    if (firstHandler) {
+        const errorBoundary = async (context, next)=>{
+            try {
+                return await firstHandler(context, next);
+            } catch (error) {
+                try {
+                    if (onError) {
+                        const result = await onError(error, context);
+                        if (result instanceof Response) return result;
+                    } else reportError?.(error);
+                } catch (configError) {
+                    reportError?.(`Error in serverConfig.onError handler: ${configError}`);
+                }
+                return (0, safe_failure_namespaceObject.createSafeFailureResponse)(error);
+            }
+        };
+        routeHandlers = Array.isArray(handler) ? [
+            errorBoundary,
+            ...restHandlers
+        ] : errorBoundary;
+    }
+    if (!policy) return routeHandlers;
+    return [
+        (0, external_cross_project_policy_js_namespaceObject.createHonoCrossProjectPolicyMiddleware)(policy, routePath),
+        ...Array.isArray(routeHandlers) ? routeHandlers : [
+            routeHandlers
+        ]
+    ];
+};
+exports.bindHonoRouteHandlers = __webpack_exports__.bindHonoRouteHandlers;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bindHonoRouteHandlers"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/hono/cross-project-policy.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__);
+__webpack_require__.d(__webpack_exports__, {
+    createHonoCrossProjectPolicyMiddleware: ()=>createHonoCrossProjectPolicyMiddleware
+});
+const evaluation_js_namespaceObject = require("../cross-project-policy/evaluation.js");
+const createHonoCrossProjectPolicyMiddleware = (policy, routePath)=>async function(context, next) {
+        const denial = (0, evaluation_js_namespaceObject.checkCrossProjectPolicyResponse)(context.req.header(), policy, {
+            method: context.req.method,
+            routePath
+        });
+        if (denial) return denial;
+        return next();
+    };
+exports.createHonoCrossProjectPolicyMiddleware = __webpack_exports__.createHonoCrossProjectPolicyMiddleware;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHonoCrossProjectPolicyMiddleware"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/hono/index.js

@@ -0,0 +1,40 @@
+"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__, {
+    bindHonoRouteHandlers: ()=>external_bind_route_handlers_js_namespaceObject.bindHonoRouteHandlers
+});
+const external_bind_route_handlers_js_namespaceObject = require("./bind-route-handlers.js");
+exports.bindHonoRouteHandlers = __webpack_exports__.bindHonoRouteHandlers;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bindHonoRouteHandlers"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/backend-federation/edge-runtime.mjs

@@ -0,0 +1,186 @@
+import { validateLoadedBackendFederatedEffectApi } from "./validate-loaded.mjs";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function parseRemoteRequest(request) {
+    const separator = request.indexOf('/');
+    if (separator <= 0 || separator === request.length - 1) throw new Error(`[BFF][Effect] Invalid backend federation request ${request}.`);
+    return {
+        expose: `./${request.slice(separator + 1).replace(/^\.\//u, '')}`,
+        remoteName: request.slice(0, separator)
+    };
+}
+function requireEdgeRemote(remotes, remoteName) {
+    const remote = remotes.find((candidate)=>candidate.name === remoteName);
+    if (void 0 === remote) throw new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`);
+    if (!/^(?:binding|service|static):/u.test(remote.entry)) throw new Error(`[BFF][Effect] Edge backend federation remote ${remote.name} must use static or service-binding entries.`);
+    return remote;
+}
+async function resolveEdgeEntry(plugins, remote) {
+    for (const plugin of plugins){
+        const entry = await plugin.loadEntry?.({
+            remoteInfo: remote
+        });
+        if (void 0 !== entry) return entry;
+    }
+    if (remote.entry.startsWith('static:') && remote.entryGlobalName) {
+        const globalEntry = globalThis[remote.entryGlobalName];
+        if ('object' == typeof globalEntry && null !== globalEntry) return globalEntry;
+        throw new Error(`[BFF][Effect] Missing static backend federation entry global ${remote.entryGlobalName} for remote ${remote.name}.`);
+    }
+    throw new Error(`[BFF][Effect] Missing static or service-binding entry provider for backend federation remote ${remote.name}.`);
+}
+var _entries = /*#__PURE__*/ new WeakMap(), _expected = /*#__PURE__*/ new WeakMap(), _hostName = /*#__PURE__*/ new WeakMap(), _allowMissingIdentityMetadata = /*#__PURE__*/ new WeakMap(), _modules = /*#__PURE__*/ new WeakMap(), _plugins = /*#__PURE__*/ new WeakMap(), _remotes = /*#__PURE__*/ new WeakMap(), _loadEntry = /*#__PURE__*/ new WeakSet(), _loadModule = /*#__PURE__*/ new WeakSet();
+class EdgeBackendFederationRuntime {
+    async loadRemote(request) {
+        const existing = _class_private_field_get(this, _modules).get(request);
+        if (void 0 !== existing) return existing;
+        const loading = _class_private_method_get(this, _loadModule, loadModule).call(this, request);
+        _class_private_field_get(this, _modules).set(request, loading);
+        loading.catch(()=>{
+            if (_class_private_field_get(this, _modules).get(request) === loading) _class_private_field_get(this, _modules).delete(request);
+        });
+        return loading;
+    }
+    constructor(options){
+        _class_private_method_init(this, _loadEntry);
+        _class_private_method_init(this, _loadModule);
+        _class_private_field_init(this, _entries, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _expected, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hostName, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _allowMissingIdentityMetadata, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _modules, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _plugins, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _remotes, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _entries, new Map());
+        _class_private_field_set(this, _modules, new Map());
+        if (void 0 !== options.entryPolicy) throw new Error('[BFF][Effect] Edge backend federation does not execute entry evaluators. Register a static or service-binding entry provider.');
+        _class_private_field_set(this, _allowMissingIdentityMetadata, true === options.allowMissingIdentityMetadata);
+        _class_private_field_set(this, _expected, options.expected);
+        _class_private_field_set(this, _hostName, options.hostName);
+        _class_private_field_set(this, _plugins, options.plugins ?? []);
+        _class_private_field_set(this, _remotes, [
+            ...options.remotes ?? []
+        ]);
+        const configuredRemote = options.remote;
+        if (void 0 !== configuredRemote) {
+            const existingIndex = _class_private_field_get(this, _remotes).findIndex((remote)=>remote.name === configuredRemote.name);
+            if (existingIndex >= 0) _class_private_field_get(this, _remotes)[existingIndex] = configuredRemote;
+            else _class_private_field_get(this, _remotes).push(configuredRemote);
+        }
+    }
+}
+function loadEntry(remote) {
+    const existing = _class_private_field_get(this, _entries).get(remote.name);
+    if (void 0 !== existing) return existing;
+    const loading = resolveEdgeEntry(_class_private_field_get(this, _plugins), remote).then(async (entry)=>{
+        await entry.init?.({
+            hostName: _class_private_field_get(this, _hostName)
+        });
+        return entry;
+    });
+    _class_private_field_get(this, _entries).set(remote.name, loading);
+    loading.catch(()=>{
+        if (_class_private_field_get(this, _entries).get(remote.name) === loading) _class_private_field_get(this, _entries).delete(remote.name);
+    });
+    return loading;
+}
+function loadModule(request) {
+    const { expose, remoteName } = parseRemoteRequest(request);
+    const remote = requireEdgeRemote(_class_private_field_get(this, _remotes), remoteName);
+    return _class_private_method_get(this, _loadEntry, loadEntry).call(this, remote).then(async (entry)=>{
+        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}/${expose.replace(/^\.\//u, '')} must load factory function.`);
+        const loaded = await factory();
+        return validateLoadedBackendFederatedEffectApi(loaded, {
+            allowMissingIdentityMetadata: _class_private_field_get(this, _allowMissingIdentityMetadata),
+            expected: _class_private_field_get(this, _expected),
+            remoteName,
+            remoteRequest: request
+        });
+    });
+}
+function createBackendFederationLoadEntryPlugin(options) {
+    return {
+        name: 'modernjs-backend-federation-load-entry',
+        loadEntry ({ remoteInfo }) {
+            return Promise.resolve(options.resolveEntry(remoteInfo)).then((entry)=>{
+                if (void 0 === entry) return;
+                return {
+                    get (id) {
+                        return ()=>Promise.resolve(entry.get(id)).then((factory)=>factory());
+                    },
+                    init (...args) {
+                        return entry.init?.(...args);
+                    }
+                };
+            });
+        }
+    };
+}
+function createBackendFederationRuntime(options) {
+    if (void 0 === options.expected || 'string' != typeof options.expected.unitId || 0 === options.expected.unitId.length || 'string' != typeof options.expected.buildMarker || 0 === options.expected.buildMarker.length) throw new Error('[BFF][Effect] Edge backend federation runtime requires expected.unitId and expected.buildMarker.');
+    return new EdgeBackendFederationRuntime(options);
+}
+function createBackendFederationRuntimeForLoad(options) {
+    return new EdgeBackendFederationRuntime(options);
+}
+export { createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, createBackendFederationRuntimeForLoad };

package/dist/esm/backend-federation/edge.mjs

@@ -0,0 +1,21 @@
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "@modern-js/utils/universal";
+import { createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, createBackendFederationRuntimeForLoad } from "./edge-runtime.mjs";
+import { LEGACY_LOAD_WARNING } from "./legacy-warning.mjs";
+import { normalizeExpose } from "./utils.mjs";
+function loadBackendFederatedEffectApi(options) {
+    if (void 0 !== options.runtime || void 0 !== options.entryPolicy) return Promise.reject(new Error('[BFF][Effect] Edge backend federation does not execute custom runtimes or entry evaluators. Register a static or service-binding entry provider.'));
+    const remoteName = options.remote?.name ?? options.remoteName;
+    if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
+    if (void 0 === options.expected) console.warn(LEGACY_LOAD_WARNING);
+    const expose = options.expose ?? options.remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE;
+    const remoteRequest = `${remoteName}/${normalizeExpose(expose)}`;
+    let runtime;
+    try {
+        runtime = createBackendFederationRuntimeForLoad(options);
+    } catch (error) {
+        return Promise.reject(error);
+    }
+    return runtime.loadRemote(remoteRequest);
+}
+export { validateExpectedBackendFederationIdentity } from "./identity.mjs";
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi };

package/dist/esm/backend-federation/entry.mjs

@@ -0,0 +1,56 @@
+import { evaluateBackendFederationCommonJsEntry, loadVerifiedBackendFederationEntry } from "@modern-js/server-runtime-extensions/backend-federation-security";
+import { isRecord, normalizeExpose } from "./utils.mjs";
+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);
+    throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} cannot load CommonJS entry ${remote.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, options) {
+    const requiresVerification = Boolean(remote.verification || options.entryPolicy?.expected);
+    const isNetworkEntry = /^https?:\/\//iu.test(remote.entry);
+    if (isNetworkEntry && !requiresVerification) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} requires verified entry bytes before network execution.`);
+    if (requiresVerification) return loadVerifiedBackendFederationEntry({
+        ...options.entryPolicy,
+        remote,
+        ...remote.verification ? {
+            verification: remote.verification
+        } : {}
+    });
+    const pluginEntry = await resolvePluginEntry(remote, options.plugins);
+    if (pluginEntry) return pluginEntry;
+    if (remote.entryGlobalName) {
+        const globalEntry = globalThis[remote.entryGlobalName];
+        if (isRecord(globalEntry)) return globalEntry;
+    }
+    if ('module' === remote.type || remote.entry.startsWith('file:')) return importModuleEntry(remote);
+    return evaluateBackendFederationCommonJsEntry(remote, new TextEncoder().encode(await readCommonJsEntrySource(remote)), options.entryPolicy?.evaluateCommonJs);
+}
+async function loadBackendFederationExpose(remote, expose, options) {
+    const entry = await loadBackendFederationEntry(remote, options);
+    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}/${normalizeExpose(expose)} must load factory function.`);
+    return factory();
+}
+export { loadBackendFederationExpose };

package/dist/esm/backend-federation/identity.mjs

@@ -0,0 +1,41 @@
+import { isRecord } from "./utils.mjs";
+function validateExpectedBackendFederationIdentity(loaded, expected, options = {}) {
+    const allowMissing = true === options.allowMissingIdentityMetadata;
+    const issues = [];
+    const contract = isRecord(loaded) ? loaded.backendFederationContract : void 0;
+    const compatibility = isRecord(contract) ? contract.compatibility : void 0;
+    if (!isRecord(compatibility)) {
+        if (allowMissing) return [];
+        return [
+            {
+                path: 'backendFederationContract.compatibility',
+                message: 'loaded module declares no compatibility metadata; delivery-unit identity cannot be validated'
+            }
+        ];
+    }
+    const unitId = compatibility.unitId;
+    if ('string' != typeof unitId || 0 === unitId.length) {
+        if (!allowMissing) issues.push({
+            path: 'backendFederationContract.compatibility.unitId',
+            message: `missing delivery-unit id; expected ${expected.unitId}`
+        });
+    } else if (unitId !== expected.unitId) issues.push({
+        path: 'backendFederationContract.compatibility.unitId',
+        message: `expected ${expected.unitId}, received ${unitId}`
+    });
+    const build = compatibility.build;
+    if ('string' != typeof build || 0 === build.length) {
+        if (!allowMissing) issues.push({
+            path: 'backendFederationContract.compatibility.build',
+            message: `missing build marker; expected ${expected.buildMarker}`
+        });
+    } else if (build !== expected.buildMarker) issues.push({
+        path: 'backendFederationContract.compatibility.build',
+        message: `expected ${expected.buildMarker}, received ${build}`
+    });
+    return issues;
+}
+function formatBackendFederationIdentityIssues(issues) {
+    return issues.map((issue)=>`${issue.path}: ${issue.message}`).join('; ');
+}
+export { formatBackendFederationIdentityIssues, validateExpectedBackendFederationIdentity };

package/dist/esm/backend-federation/index.mjs

@@ -0,0 +1,4 @@
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "@modern-js/utils/universal";
+export { validateExpectedBackendFederationIdentity } from "./identity.mjs";
+export { createBackendFederationLoadEntryPlugin } from "./plugin.mjs";
+export { createBackendFederationRuntime } from "./runtime.mjs";

package/dist/esm/backend-federation/legacy-warning.mjs

@@ -0,0 +1,2 @@
+const LEGACY_LOAD_WARNING = '[BFF][Effect] loadBackendFederatedEffectApi was called without an expected delivery-unit identity (expected.unitId + expected.buildMarker). Identity-less public backend loads are deprecated (ADR-0019/MV-G23) and will be rejected in a future major.';
+export { LEGACY_LOAD_WARNING };

package/dist/esm/backend-federation/load.mjs

@@ -0,0 +1,34 @@
+import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "@modern-js/utils/universal";
+import { LEGACY_LOAD_WARNING } from "./legacy-warning.mjs";
+import { collectRemotes } from "./remotes.mjs";
+import { createBackendFederationRuntime } from "./runtime.mjs";
+import { normalizeExpose } from "./utils.mjs";
+import { validateLoadedBackendFederatedEffectApi } from "./validate-loaded.mjs";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Logger_1691a01b from "effect/Logger";
+const legacyWarningLogger = __rspack_external_effect_Logger_1691a01b.withLeveledConsole(__rspack_external_effect_Logger_1691a01b.formatLogFmt);
+function warnLegacyLoad() {
+    __rspack_external_effect_Effect_41060786.runSync(__rspack_external_effect_Effect_41060786.provideService(__rspack_external_effect_Effect_41060786.logWarning(LEGACY_LOAD_WARNING), __rspack_external_effect_Logger_1691a01b.CurrentLoggers, new Set([
+        legacyWarningLogger
+    ])));
+}
+function loadBackendFederatedEffectApi(options) {
+    const remoteName = options.remote?.name ?? options.remoteName;
+    if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
+    if (void 0 === options.expected) warnLegacyLoad();
+    if (void 0 !== options.runtime) {
+        const configuredRemote = collectRemotes(options).find((remote)=>remote.name === remoteName);
+        if (void 0 === configuredRemote || !/^(?:binding|service|static):/u.test(configuredRemote.entry)) return Promise.reject(new Error('[BFF][Effect] A custom Module Federation runtime requires a caller-pinned static or service-binding remote and cannot execute network backend federation entries.'));
+        if (void 0 !== configuredRemote.verification || options.entryPolicy?.expected !== void 0) return Promise.reject(new Error('[BFF][Effect] A custom Module Federation runtime cannot bypass verified backend entry loading.'));
+    }
+    const runtime = options.runtime ?? createBackendFederationRuntime(options);
+    const expose = options.expose ?? options.remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE;
+    const remoteRequest = `${remoteName}/${normalizeExpose(expose)}`;
+    return runtime.loadRemote(remoteRequest).then((loaded)=>validateLoadedBackendFederatedEffectApi(loaded, {
+            allowMissingIdentityMetadata: options.allowMissingIdentityMetadata,
+            expected: options.expected,
+            remoteName,
+            remoteRequest
+        }));
+}
+export { loadBackendFederatedEffectApi };

package/dist/esm/backend-federation/node.mjs

@@ -0,0 +1,12 @@
+import { evaluateNodeBackendFederationCommonJs } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
+import { loadBackendFederatedEffectApi } from "./load.mjs";
+function node_loadBackendFederatedEffectApi(options) {
+    return loadBackendFederatedEffectApi({
+        ...options,
+        entryPolicy: {
+            ...options.entryPolicy,
+            evaluateCommonJs: options.entryPolicy?.evaluateCommonJs ?? evaluateNodeBackendFederationCommonJs
+        }
+    });
+}
+export { node_loadBackendFederatedEffectApi as loadBackendFederatedEffectApi };

package/dist/esm/backend-federation/plugin.mjs

@@ -0,0 +1,25 @@
+function createBackendFederationLoadEntryPlugin(options) {
+    return {
+        name: 'modernjs-backend-federation-load-entry',
+        loadEntry ({ remoteInfo }) {
+            return Promise.resolve(options.resolveEntry({
+                name: remoteInfo.name,
+                entry: remoteInfo.entry,
+                type: remoteInfo.type,
+                entryGlobalName: remoteInfo.entryGlobalName,
+                shareScope: remoteInfo.shareScope
+            })).then((entry)=>{
+                if (void 0 === entry) return;
+                return {
+                    get (id) {
+                        return ()=>Promise.resolve(entry.get(id)).then((factory)=>factory());
+                    },
+                    init (...args) {
+                        return entry.init?.(...args);
+                    }
+                };
+            });
+        }
+    };
+}
+export { createBackendFederationLoadEntryPlugin };

package/dist/esm/backend-federation/remotes.mjs

@@ -0,0 +1,13 @@
+function collectRemotes(options) {
+    const remotes = [
+        ...options.remotes ?? []
+    ];
+    const configuredRemote = options.remote;
+    if (void 0 !== configuredRemote) {
+        const existingIndex = remotes.findIndex((remote)=>remote.name === configuredRemote.name);
+        if (existingIndex >= 0) remotes[existingIndex] = configuredRemote;
+        else remotes.push(configuredRemote);
+    }
+    return remotes;
+}
+export { collectRemotes };

package/dist/esm/backend-federation/runtime.mjs

@@ -0,0 +1,90 @@
+import { ModuleFederation } from "@module-federation/runtime";
+import { loadBackendFederationExpose } from "./entry.mjs";
+import { createBackendFederationLoadEntryPlugin } from "./plugin.mjs";
+import { collectRemotes } from "./remotes.mjs";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+let nextRuntimeId = 0;
+function parseRemoteRequest(request) {
+    const [remoteName, ...exposeParts] = request.split('/');
+    if (void 0 === remoteName || 0 === remoteName.length || 0 === exposeParts.length) return;
+    return remoteName;
+}
+function createLocalEntryPlugin(options, remotes) {
+    return createBackendFederationLoadEntryPlugin({
+        resolveEntry (resolvedRemote) {
+            const remote = remotes.find((candidate)=>candidate.name === resolvedRemote.name);
+            if (void 0 === remote) return;
+            return {
+                get (expose) {
+                    return ()=>loadBackendFederationExpose(remote, expose, options);
+                }
+            };
+        }
+    });
+}
+function isolateRegisteredRemoteEntries(remotes) {
+    const runtimeId = nextRuntimeId;
+    nextRuntimeId += 1;
+    return remotes.map((remote)=>({
+            ...remote,
+            entry: `${remote.entry}#modernjs-backend-runtime-${runtimeId}`
+        }));
+}
+var _remoteNames = /*#__PURE__*/ new WeakMap();
+class BackendFederationRuntime extends ModuleFederation {
+    loadRemote(request, loadOptions) {
+        const remoteName = parseRemoteRequest(request);
+        if (void 0 === remoteName) return Promise.reject(new Error(`[BFF][Effect] Invalid backend federation request ${request}.`));
+        if (!_class_private_field_get(this, _remoteNames).has(remoteName)) return Promise.reject(new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`));
+        return super.loadRemote(request, loadOptions);
+    }
+    constructor(options, remotes){
+        super({
+            name: options.hostName,
+            remotes: isolateRegisteredRemoteEntries(remotes),
+            shared: {},
+            plugins: [
+                createLocalEntryPlugin(options, remotes)
+            ]
+        }), _class_private_field_init(this, _remoteNames, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _remoteNames, new Set(remotes.map((remote)=>remote.name)));
+    }
+}
+function createBackendFederationRuntime(options) {
+    const remotes = collectRemotes(options);
+    return new BackendFederationRuntime(options, remotes);
+}
+export { createBackendFederationRuntime };