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

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

@@ -0,0 +1,42 @@
+import "node:module";
+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-node/backend-federation/index.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+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-node/backend-federation/legacy-warning.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+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-node/backend-federation/load.mjs

@@ -0,0 +1,35 @@
+import "node:module";
+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-node/backend-federation/node.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+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-node/backend-federation/plugin.mjs

@@ -0,0 +1,26 @@
+import "node:module";
+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-node/backend-federation/remotes.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+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-node/backend-federation/runtime.mjs

@@ -0,0 +1,91 @@
+import "node:module";
+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 };

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

@@ -0,0 +1 @@
+import "node:module";

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

@@ -0,0 +1,8 @@
+import "node:module";
+function normalizeExpose(expose) {
+    return expose.replace(/^\.\//u, '');
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+export { isRecord, normalizeExpose };

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

@@ -0,0 +1,19 @@
+import "node:module";
+import { formatBackendFederationIdentityIssues, validateExpectedBackendFederationIdentity } from "./identity.mjs";
+import { isRecord } from "./utils.mjs";
+function validateLoadedBackendFederatedEffectApi(loaded, options) {
+    if (!isRecord(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must load an object module.`);
+    const backendContract = loaded.backendFederationContract;
+    if (!isRecord(backendContract) || true !== backendContract.strictEffectApproach) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must expose strict Effect metadata (strictEffectApproach: true).`);
+    if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
+    if ('string' == typeof backendContract.name && backendContract.name !== options.remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} metadata name mismatch: expected ${options.remoteName}, received ${backendContract.name}.`);
+    if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must expose runtime.`);
+    if (void 0 !== options.expected) {
+        const issues = validateExpectedBackendFederationIdentity(loaded, options.expected, {
+            allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
+        });
+        if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} delivery-unit identity mismatch: ${formatBackendFederationIdentityIssues(issues)}.`);
+    }
+    return loaded;
+}
+export { validateLoadedBackendFederatedEffectApi };

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

@@ -0,0 +1,33 @@
+import "node:module";
+const BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT = 'modernjs:microvertical-server-fallback';
+class BackendFederationManifestAdapterError extends Error {
+    constructor(code, message, cause, details){
+        super(message), this.failureEvent = BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT;
+        this.name = 'BackendFederationManifestAdapterError';
+        this.code = code;
+        if (details) this.details = details;
+        if (void 0 !== cause) this.cause = cause;
+    }
+}
+function assertManifestAdapter(condition, code, message) {
+    if (!condition) throw new BackendFederationManifestAdapterError(code, message);
+}
+function assertVersionValue(actual, expected, label, details) {
+    if (void 0 === expected) return;
+    if (actual !== expected) throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${label} mismatch: expected ${expected}, received ${actual ?? 'undefined'}.`, void 0, {
+        label,
+        expected,
+        received: actual,
+        ...details
+    });
+}
+function assertConsistentValue(left, right, label, details) {
+    if (void 0 === left || void 0 === right || left === right) return;
+    throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${label} mismatch: expected ${left}, received ${right}.`, void 0, {
+        label,
+        expected: left,
+        received: right,
+        ...details
+    });
+}
+export { BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT, BackendFederationManifestAdapterError, assertConsistentValue, assertManifestAdapter, assertVersionValue };

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

@@ -0,0 +1,4 @@
+import "node:module";
+export { BackendFederationManifestAdapterError } from "./errors.mjs";
+export { loadBackendFederationManifest } from "./reference.mjs";
+export { resolveBackendFederationRemoteFromManifest } from "./remote.mjs";

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

@@ -0,0 +1,136 @@
+import "node:module";
+import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "../backend-federation/index.mjs";
+import { loadBackendFederatedEffectApi } from "../backend-federation/load.mjs";
+import { BackendFederationManifestAdapterError } from "./errors.mjs";
+import { loadBackendFederationManifest } from "./reference.mjs";
+import { resolveBackendFederationRemoteFromManifest } from "./remote.mjs";
+import { classifyLoadError, validateBackendFederationManifest, validateLoadedBackendFederationContract } from "./validation.mjs";
+function createManifestLoadScope(options) {
+    const controller = new AbortController();
+    const policyTimeouts = [
+        options.manifestPolicy?.timeoutMs,
+        options.entryPolicy?.timeoutMs
+    ].filter((timeout)=>void 0 !== timeout);
+    const configuredTimeouts = [
+        options.timeoutMs,
+        ...policyTimeouts
+    ].filter((timeout)=>void 0 !== timeout);
+    for (const timeout of configuredTimeouts)if (!Number.isSafeInteger(timeout) || timeout < 0) throw new BackendFederationManifestAdapterError('manifest_invalid', '[BFF][Effect] Backend federation timeoutMs must be a non-negative safe integer.');
+    const timeoutMs = options.timeoutMs ?? (policyTimeouts.length > 0 ? Math.min(...policyTimeouts) : 0);
+    const inputSignals = [
+        options.signal,
+        options.manifestPolicy?.signal,
+        options.entryPolicy?.signal
+    ].filter((signal)=>void 0 !== signal);
+    const abortListeners = [];
+    let timedOut = false;
+    const forwardAbort = (signal)=>{
+        controller.abort(signal.reason);
+    };
+    for (const signal of inputSignals){
+        if (signal.aborted) {
+            forwardAbort(signal);
+            break;
+        }
+        const listener = ()=>forwardAbort(signal);
+        abortListeners.push([
+            signal,
+            listener
+        ]);
+        signal.addEventListener('abort', listener, {
+            once: true
+        });
+    }
+    const timeout = timeoutMs > 0 ? setTimeout(()=>{
+        if (controller.signal.aborted) return;
+        timedOut = true;
+        controller.abort(new BackendFederationManifestAdapterError('timeout', `[BFF][Effect] Backend federation load timed out after ${timeoutMs}ms.`));
+    }, timeoutMs) : void 0;
+    return {
+        cleanup () {
+            if (timeout) clearTimeout(timeout);
+            for (const [signal, listener] of abortListeners)signal.removeEventListener('abort', listener);
+        },
+        signal: controller.signal,
+        timedOut: ()=>timedOut,
+        timeoutMs
+    };
+}
+function isRemoteManifestReference(options) {
+    if (void 0 !== options.manifest || options.manifestPath) return false;
+    return Boolean(options.manifestUrl || options.manifestEnv);
+}
+function hasPinnedRemoteEntryExpectation(options) {
+    const expected = options.entryPolicy?.expected;
+    return 'number' == typeof expected?.byteLength && 'string' == typeof expected.entryUrl && 'string' == typeof expected.remoteName && 'string' == typeof expected.sha256;
+}
+function isCallerPinnedStaticRemote(options, remote) {
+    return options.remote?.entry === remote.entry && options.remote?.name === remote.name && /^(?:binding|service|static):/u.test(remote.entry);
+}
+function throwIfManifestLoadAborted(signal) {
+    if (signal.aborted) throw new BackendFederationManifestAdapterError('remote_unavailable', '[BFF][Effect] Backend federation load was aborted before remote execution.', signal.reason);
+}
+async function loadBackendFederatedEffectApiFromManifest(options) {
+    let manifest;
+    let remote;
+    let scope;
+    try {
+        scope = createManifestLoadScope(options);
+        throwIfManifestLoadAborted(scope.signal);
+        manifest = await loadBackendFederationManifest({
+            ...options,
+            manifestPolicy: {
+                ...options.manifestPolicy,
+                signal: scope.signal,
+                timeoutMs: 0
+            },
+            signal: scope.signal,
+            timeoutMs: 0
+        });
+        validateBackendFederationManifest(manifest, options.expected);
+        remote = resolveBackendFederationRemoteFromManifest(manifest, options.remote);
+        throwIfManifestLoadAborted(scope.signal);
+        const remoteManifest = isRemoteManifestReference(options);
+        if (remoteManifest && void 0 !== options.runtime) throw new BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} cannot use a custom runtime selected by a network manifest.`);
+        if (remoteManifest && !/^https?:\/\//iu.test(remote.entry) && !isCallerPinnedStaticRemote(options, remote)) throw new BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation network manifests cannot select local, global, or plugin entry ${remote.entry}. Pin a static/service binding in caller configuration or use a verified HTTP(S) entry.`);
+        if (remoteManifest && /^https?:\/\//iu.test(remote.entry) && !hasPinnedRemoteEntryExpectation(options)) throw new BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} from a network manifest requires caller-pinned entryUrl, remoteName, sha256, and byteLength values.`);
+        if (/^https?:\/\//iu.test(remote.entry) && void 0 === remote.verification && options.entryPolicy?.expected === void 0) throw new BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} requires entry.sha256 and entry.byteLength before network execution.`);
+        if (/^https?:\/\//iu.test(remote.entry) && void 0 !== options.runtime) throw new BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} cannot use a custom runtime for network entry execution.`);
+        const loaded = await loadBackendFederatedEffectApi({
+            hostName: options.hostName,
+            remote,
+            ...options.plugins ? {
+                plugins: options.plugins
+            } : {},
+            entryPolicy: {
+                ...options.entryPolicy,
+                signal: scope.signal,
+                timeoutMs: 0
+            },
+            ...options.runtime ? {
+                runtime: options.runtime
+            } : {},
+            ...options.expected?.unitId && options.expected.buildMarker ? {
+                expected: {
+                    unitId: options.expected.unitId,
+                    buildMarker: options.expected.buildMarker
+                },
+                allowMissingIdentityMetadata: true
+            } : {}
+        }).catch((error)=>{
+            throw new BackendFederationManifestAdapterError(scope?.timedOut() === true ? 'timeout' : classifyLoadError(error), `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE}.`, error);
+        });
+        validateLoadedBackendFederationContract(loaded, manifest, remote);
+        return loaded;
+    } catch (error) {
+        const adapterError = scope?.timedOut() === true ? new BackendFederationManifestAdapterError('timeout', `[BFF][Effect] Backend federation load timed out after ${scope.timeoutMs}ms.`, error) : error instanceof BackendFederationManifestAdapterError ? error : new BackendFederationManifestAdapterError('remote_unavailable', '[BFF][Effect] Backend federation manifest adapter failed.', error);
+        if (options.fallback) return options.fallback(adapterError, {
+            manifest,
+            remote
+        });
+        throw adapterError;
+    } finally{
+        scope?.cleanup();
+    }
+}
+export { loadBackendFederatedEffectApiFromManifest };

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

@@ -0,0 +1,43 @@
+import "node:module";
+import { backendFederationMetadata, backendFederationVersionBoundary } from "@modern-js/utils/universal";
+function stringValue(value) {
+    return 'string' == typeof value && value.length > 0 ? value : void 0;
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+function recordField(value, field) {
+    const fieldValue = value?.[field];
+    return isRecord(fieldValue) ? fieldValue : void 0;
+}
+function resolveRemoteEntryFromMetadata(manifest) {
+    const metaData = recordField(manifest, 'metaData');
+    const remoteEntry = recordField(metaData, 'remoteEntry');
+    const publicPath = stringValue(metaData?.publicPath) ?? stringValue(metaData?.ssrPublicPath);
+    const entryName = stringValue(remoteEntry?.name);
+    if (!publicPath || !entryName) return;
+    const entryPath = stringValue(remoteEntry?.path) ?? '';
+    const normalizedBase = publicPath.replace(/\/+$/u, '');
+    const normalizedPath = entryPath.replace(/^\/+|\/+$/gu, '');
+    return [
+        normalizedBase,
+        normalizedPath,
+        entryName
+    ].filter(Boolean).join('/');
+}
+function metadata_backendFederationMetadata(manifest) {
+    return backendFederationMetadata(manifest);
+}
+function versionBoundaryMetadata(manifest) {
+    return backendFederationVersionBoundary(manifest);
+}
+function deliveryUnitMetadata(record) {
+    return recordField(record, 'deliveryUnit');
+}
+function manifestDeliveryUnit(backendFederation, boundary) {
+    return {
+        boundary: deliveryUnitMetadata(boundary),
+        top: deliveryUnitMetadata(backendFederation)
+    };
+}
+export { deliveryUnitMetadata, isRecord, manifestDeliveryUnit, metadata_backendFederationMetadata as backendFederationMetadata, recordField, resolveRemoteEntryFromMetadata, stringValue, versionBoundaryMetadata };

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

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

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

@@ -0,0 +1,89 @@
+import "node:module";
+import { BackendFederationRemoteEntryError, loadBoundedBackendFederationResource, redactBackendFederationUrl } from "@modern-js/server-runtime-extensions/backend-federation-security";
+import { BACKEND_FEDERATION_MANIFEST_FILE } from "../backend-federation/index.mjs";
+import { BackendFederationManifestAdapterError, assertManifestAdapter } from "./errors.mjs";
+import { isRecord } from "./metadata.mjs";
+function getProcessEnv() {
+    return "u" > typeof process ? process.env : void 0;
+}
+function resolveManifestReferenceSource(options) {
+    if (options.manifestPath) return 'path';
+    if (options.manifestUrl) return 'url';
+    if (options.manifestEnv) return 'env';
+}
+function resolveBackendFederationManifestReference(options) {
+    if (options.manifestPath) return options.manifestPath;
+    if (options.manifestUrl) return options.manifestUrl;
+    if (!options.manifestEnv) return;
+    return options.env?.[options.manifestEnv] ?? getProcessEnv()?.[options.manifestEnv];
+}
+function assertExpectedIdentityForReference(options, source) {
+    if (void 0 === source || 'path' === source) return;
+    if (options.expected?.unitId && options.expected.buildMarker) return;
+    throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${source} manifest references require expected.unitId and expected.buildMarker.`, void 0, {
+        label: 'expected.deliveryUnit',
+        expected: 'unitId + buildMarker',
+        received: options.expected,
+        referenceSource: source
+    });
+}
+function isHttpUrl(value) {
+    return /^https?:\/\//iu.test(value);
+}
+function referenceForDiagnostics(reference) {
+    return isHttpUrl(reference) ? redactBackendFederationUrl(reference) : '[local manifest]';
+}
+async function readFileReference(reference) {
+    const [{ fileURLToPath }, fs] = await Promise.all([
+        import("node:url"),
+        import("node:fs/promises")
+    ]);
+    const filePath = reference.startsWith('file:') ? fileURLToPath(reference) : reference;
+    return fs.readFile(filePath, 'utf8');
+}
+async function withTimeout(promise, timeoutMs, label) {
+    if (!timeoutMs || timeoutMs <= 0) return promise;
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject)=>{
+                timeout = setTimeout(()=>{
+                    reject(new BackendFederationManifestAdapterError('timeout', `[BFF][Effect] ${label} timed out after ${timeoutMs}ms.`));
+                }, timeoutMs);
+            })
+        ]);
+    } finally{
+        if (timeout) clearTimeout(timeout);
+    }
+}
+async function loadBackendFederationManifest(options) {
+    if (options.manifest) return options.manifest;
+    const reference = resolveBackendFederationManifestReference(options);
+    if (!reference) throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest reference is missing. Pass manifest, manifestPath, manifestUrl, or manifestEnv for ${BACKEND_FEDERATION_MANIFEST_FILE}.`);
+    assertExpectedIdentityForReference(options, resolveManifestReferenceSource(options));
+    const referenceSource = resolveManifestReferenceSource(options);
+    if ('path' === referenceSource && isHttpUrl(reference)) throw new BackendFederationManifestAdapterError('manifest_unavailable', '[BFF][Effect] Backend federation manifestPath must identify an explicit local file. Use manifestUrl for HTTP(S) manifests.');
+    if (('url' === referenceSource || 'env' === referenceSource) && !isHttpUrl(reference)) throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation ${referenceSource} manifest references must use HTTP(S). Use manifestPath for an explicit local file.`);
+    try {
+        const diagnosticReference = referenceForDiagnostics(reference);
+        const source = isHttpUrl(reference) ? new TextDecoder('utf-8', {
+            fatal: true
+        }).decode(await loadBoundedBackendFederationResource(reference, {
+            allowInsecureHttp: options.manifestPolicy?.allowInsecureHttp === true,
+            fetch: options.fetch,
+            kind: 'manifest',
+            maxBytes: options.manifestPolicy?.maxBytes,
+            signal: options.manifestPolicy?.signal ?? options.signal,
+            timeoutMs: options.manifestPolicy?.timeoutMs ?? options.timeoutMs
+        })) : await withTimeout(readFileReference(reference), options.manifestPolicy?.timeoutMs ?? options.timeoutMs, 'Backend federation local manifest');
+        const manifest = JSON.parse(source);
+        assertManifestAdapter(isRecord(manifest), 'manifest_invalid', `[BFF][Effect] Backend federation manifest ${diagnosticReference} must be a JSON object.`);
+        return manifest;
+    } catch (error) {
+        if (error instanceof BackendFederationManifestAdapterError) throw error;
+        if (error instanceof BackendFederationRemoteEntryError) throw new BackendFederationManifestAdapterError('timeout' === error.code ? 'timeout' : 'manifest_unavailable', `[BFF][Effect] ${error.message}`, error, error.details);
+        throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${referenceForDiagnostics(reference)} could not be loaded.`, error);
+    }
+}
+export { loadBackendFederationManifest, resolveBackendFederationManifestReference, withTimeout };

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

@@ -0,0 +1,44 @@
+import "node:module";
+import { BackendFederationRemoteEntryError, resolveBackendFederationRemoteEntryVerification } from "@modern-js/server-runtime-extensions/backend-federation-security";
+import { backendFederationExposeNames } from "@modern-js/utils/universal";
+import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "../backend-federation/index.mjs";
+import { BackendFederationManifestAdapterError, assertManifestAdapter } from "./errors.mjs";
+import { backendFederationMetadata, recordField, resolveRemoteEntryFromMetadata, stringValue } from "./metadata.mjs";
+function resolveBackendFederationRemoteFromManifest(manifest, remoteOverride = {}) {
+    const backendFederation = backendFederationMetadata(manifest);
+    const entry = recordField(manifest, 'entry');
+    const metaData = recordField(manifest, 'metaData');
+    const remoteEntry = recordField(metaData, 'remoteEntry');
+    const remoteName = remoteOverride.name ?? stringValue(backendFederation?.name) ?? stringValue(manifest.name) ?? stringValue(manifest.id);
+    const manifestEntryUrl = stringValue(backendFederation?.containerEntry) ?? stringValue(entry?.url) ?? resolveRemoteEntryFromMetadata(manifest);
+    const remoteEntryUrl = remoteOverride.entry ?? manifestEntryUrl;
+    const remoteType = remoteOverride.type ?? stringValue(backendFederation?.remoteType) ?? stringValue(entry?.type) ?? stringValue(remoteEntry?.type) ?? 'module';
+    const expose = remoteOverride.expose ?? backendFederationExposeNames(backendFederation)[0] ?? BACKEND_FEDERATION_EFFECT_EXPOSE;
+    let verification;
+    try {
+        const manifestVerification = resolveBackendFederationRemoteEntryVerification(manifest);
+        verification = remoteOverride.verification ?? (remoteEntryUrl === manifestEntryUrl ? manifestVerification : void 0);
+    } catch (cause) {
+        if (cause instanceof BackendFederationRemoteEntryError) throw new BackendFederationManifestAdapterError('identity_mismatch' === cause.code ? 'version_mismatch' : 'manifest_invalid', `[BFF][Effect] ${cause.message}`, cause, cause.details);
+        throw cause;
+    }
+    assertManifestAdapter(remoteName, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare a remote name.');
+    assertManifestAdapter(remoteEntryUrl, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare a backend remote entry URL.');
+    assertManifestAdapter(expose === BACKEND_FEDERATION_EFFECT_EXPOSE, 'manifest_invalid', `[BFF][Effect] Backend federation manifest expose must be ${BACKEND_FEDERATION_EFFECT_EXPOSE}.`);
+    return {
+        name: remoteName,
+        entry: remoteEntryUrl,
+        type: remoteType,
+        ...verification ? {
+            verification
+        } : {},
+        ...remoteOverride.entryGlobalName ? {
+            entryGlobalName: remoteOverride.entryGlobalName
+        } : {},
+        expose,
+        ...remoteOverride.shareScope ? {
+            shareScope: remoteOverride.shareScope
+        } : {}
+    };
+}
+export { resolveBackendFederationRemoteFromManifest };

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

@@ -0,0 +1 @@
+import "node:module";