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

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

@@ -0,0 +1,83 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const 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
+    });
+}
+__webpack_require__.d(__webpack_exports__, {
+    BackendFederationManifestAdapterError: ()=>BackendFederationManifestAdapterError,
+    assertConsistentValue: ()=>assertConsistentValue,
+    assertManifestAdapter: ()=>assertManifestAdapter,
+    assertVersionValue: ()=>assertVersionValue
+}, {
+    BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT: BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT
+});
+exports.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT;
+exports.BackendFederationManifestAdapterError = __webpack_exports__.BackendFederationManifestAdapterError;
+exports.assertConsistentValue = __webpack_exports__.assertConsistentValue;
+exports.assertManifestAdapter = __webpack_exports__.assertManifestAdapter;
+exports.assertVersionValue = __webpack_exports__.assertVersionValue;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT",
+    "BackendFederationManifestAdapterError",
+    "assertConsistentValue",
+    "assertManifestAdapter",
+    "assertVersionValue"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,55 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT: ()=>external_errors_js_namespaceObject.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT,
+    BackendFederationManifestAdapterError: ()=>external_errors_js_namespaceObject.BackendFederationManifestAdapterError,
+    loadBackendFederatedEffectApiFromManifest: ()=>external_load_js_namespaceObject.loadBackendFederatedEffectApiFromManifest,
+    loadBackendFederationManifest: ()=>external_reference_js_namespaceObject.loadBackendFederationManifest,
+    resolveBackendFederationRemoteFromManifest: ()=>external_remote_js_namespaceObject.resolveBackendFederationRemoteFromManifest
+});
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_load_js_namespaceObject = require("./load.js");
+const external_reference_js_namespaceObject = require("./reference.js");
+const external_remote_js_namespaceObject = require("./remote.js");
+exports.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT;
+exports.BackendFederationManifestAdapterError = __webpack_exports__.BackendFederationManifestAdapterError;
+exports.loadBackendFederatedEffectApiFromManifest = __webpack_exports__.loadBackendFederatedEffectApiFromManifest;
+exports.loadBackendFederationManifest = __webpack_exports__.loadBackendFederationManifest;
+exports.resolveBackendFederationRemoteFromManifest = __webpack_exports__.resolveBackendFederationRemoteFromManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT",
+    "BackendFederationManifestAdapterError",
+    "loadBackendFederatedEffectApiFromManifest",
+    "loadBackendFederationManifest",
+    "resolveBackendFederationRemoteFromManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,74 @@
+"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__, {
+    loadBackendFederatedEffectApiFromManifest: ()=>loadBackendFederatedEffectApiFromManifest
+});
+const external_backend_federation_js_namespaceObject = require("../backend-federation.js");
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_reference_js_namespaceObject = require("./reference.js");
+const external_remote_js_namespaceObject = require("./remote.js");
+const external_validation_js_namespaceObject = require("./validation.js");
+async function loadBackendFederatedEffectApiFromManifest(options) {
+    let manifest;
+    let remote;
+    try {
+        manifest = await (0, external_reference_js_namespaceObject.loadBackendFederationManifest)(options);
+        (0, external_validation_js_namespaceObject.validateBackendFederationManifest)(manifest, options.expected);
+        remote = (0, external_remote_js_namespaceObject.resolveBackendFederationRemoteFromManifest)(manifest, options.remote);
+        const loaded = await (0, external_reference_js_namespaceObject.withTimeout)((0, external_backend_federation_js_namespaceObject.loadBackendFederatedEffectApi)({
+            hostName: options.hostName,
+            remote,
+            ...options.plugins ? {
+                plugins: options.plugins
+            } : {},
+            ...options.runtime ? {
+                runtime: options.runtime
+            } : {}
+        }), options.timeoutMs, `Backend federation remote ${remote.name}`).catch((error)=>{
+            throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError((0, external_validation_js_namespaceObject.classifyLoadError)(error), `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE}.`, error);
+        });
+        (0, external_validation_js_namespaceObject.validateLoadedBackendFederationContract)(loaded, manifest, remote);
+        return loaded;
+    } catch (error) {
+        const adapterError = error instanceof external_errors_js_namespaceObject.BackendFederationManifestAdapterError ? error : new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('remote_unavailable', '[BFF][Effect] Backend federation manifest adapter failed.', error);
+        if (options.fallback) return options.fallback(adapterError, {
+            manifest,
+            remote
+        });
+        throw adapterError;
+    }
+}
+exports.loadBackendFederatedEffectApiFromManifest = __webpack_exports__.loadBackendFederatedEffectApiFromManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadBackendFederatedEffectApiFromManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,101 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    backendFederationMetadata: ()=>backendFederationMetadata,
+    deliveryUnitMetadata: ()=>deliveryUnitMetadata,
+    isRecord: ()=>isRecord,
+    manifestDeliveryUnit: ()=>manifestDeliveryUnit,
+    recordField: ()=>recordField,
+    resolveRemoteEntryFromMetadata: ()=>resolveRemoteEntryFromMetadata,
+    stringValue: ()=>stringValue,
+    versionBoundaryMetadata: ()=>versionBoundaryMetadata
+});
+const universal_namespaceObject = require("@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 backendFederationMetadata(manifest) {
+    return (0, universal_namespaceObject.backendFederationMetadata)(manifest);
+}
+function versionBoundaryMetadata(manifest) {
+    return (0, universal_namespaceObject.backendFederationVersionBoundary)(manifest);
+}
+function deliveryUnitMetadata(record) {
+    return recordField(record, 'deliveryUnit');
+}
+function manifestDeliveryUnit(backendFederation, boundary) {
+    return {
+        boundary: deliveryUnitMetadata(boundary),
+        top: deliveryUnitMetadata(backendFederation)
+    };
+}
+exports.backendFederationMetadata = __webpack_exports__.backendFederationMetadata;
+exports.deliveryUnitMetadata = __webpack_exports__.deliveryUnitMetadata;
+exports.isRecord = __webpack_exports__.isRecord;
+exports.manifestDeliveryUnit = __webpack_exports__.manifestDeliveryUnit;
+exports.recordField = __webpack_exports__.recordField;
+exports.resolveRemoteEntryFromMetadata = __webpack_exports__.resolveRemoteEntryFromMetadata;
+exports.stringValue = __webpack_exports__.stringValue;
+exports.versionBoundaryMetadata = __webpack_exports__.versionBoundaryMetadata;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "backendFederationMetadata",
+    "deliveryUnitMetadata",
+    "isRecord",
+    "manifestDeliveryUnit",
+    "recordField",
+    "resolveRemoteEntryFromMetadata",
+    "stringValue",
+    "versionBoundaryMetadata"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,117 @@
+"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__, {
+    loadBackendFederationManifest: ()=>loadBackendFederationManifest,
+    withTimeout: ()=>withTimeout
+});
+const external_backend_federation_js_namespaceObject = require("../backend-federation.js");
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_metadata_js_namespaceObject = require("./metadata.js");
+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 resolveManifestReference(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 || options.allowLegacyManifest) return;
+    if (options.expected?.unitId && options.expected.buildMarker) return;
+    throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${source} manifest references require expected.unitId and expected.buildMarker. Pass allowLegacyManifest: true to load legacy manifest references.`, void 0, {
+        label: 'expected.deliveryUnit',
+        expected: 'unitId + buildMarker',
+        received: options.expected,
+        referenceSource: source
+    });
+}
+function isHttpUrl(value) {
+    return /^https?:\/\//iu.test(value);
+}
+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 external_errors_js_namespaceObject.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 = resolveManifestReference(options);
+    if (!reference) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest reference is missing. Pass manifest, manifestPath, manifestUrl, or manifestEnv for ${external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE}.`);
+    assertExpectedIdentityForReference(options, resolveManifestReferenceSource(options));
+    try {
+        const source = isHttpUrl(reference) ? await (async ()=>{
+            const fetchManifest = options.fetch ?? globalThis.fetch;
+            if (!fetchManifest) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} requires a fetch implementation.`);
+            const response = await withTimeout(fetchManifest(reference), options.timeoutMs, `Backend federation manifest ${reference}`);
+            if (!response.ok) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} returned HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ''}.`);
+            return response.text();
+        })() : await withTimeout(readFileReference(reference), options.timeoutMs, `Backend federation manifest ${reference}`);
+        const manifest = JSON.parse(source);
+        (0, external_errors_js_namespaceObject.assertManifestAdapter)((0, external_metadata_js_namespaceObject.isRecord)(manifest), 'manifest_invalid', `[BFF][Effect] Backend federation manifest ${reference} must be a JSON object.`);
+        return manifest;
+    } catch (error) {
+        if (error instanceof external_errors_js_namespaceObject.BackendFederationManifestAdapterError) throw error;
+        throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} could not be loaded.`, error);
+    }
+}
+exports.loadBackendFederationManifest = __webpack_exports__.loadBackendFederationManifest;
+exports.withTimeout = __webpack_exports__.withTimeout;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadBackendFederationManifest",
+    "withTimeout"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,68 @@
+"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__, {
+    resolveBackendFederationRemoteFromManifest: ()=>resolveBackendFederationRemoteFromManifest
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_backend_federation_js_namespaceObject = require("../backend-federation.js");
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_metadata_js_namespaceObject = require("./metadata.js");
+function resolveBackendFederationRemoteFromManifest(manifest, remoteOverride = {}) {
+    const backendFederation = (0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest);
+    const entry = (0, external_metadata_js_namespaceObject.recordField)(manifest, 'entry');
+    const metaData = (0, external_metadata_js_namespaceObject.recordField)(manifest, 'metaData');
+    const remoteEntry = (0, external_metadata_js_namespaceObject.recordField)(metaData, 'remoteEntry');
+    const remoteName = remoteOverride.name ?? (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.name) ?? (0, external_metadata_js_namespaceObject.stringValue)(manifest.name) ?? (0, external_metadata_js_namespaceObject.stringValue)(manifest.id);
+    const remoteEntryUrl = remoteOverride.entry ?? (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.containerEntry) ?? (0, external_metadata_js_namespaceObject.stringValue)(entry?.url) ?? (0, external_metadata_js_namespaceObject.resolveRemoteEntryFromMetadata)(manifest);
+    const remoteType = remoteOverride.type ?? (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.remoteType) ?? (0, external_metadata_js_namespaceObject.stringValue)(entry?.type) ?? (0, external_metadata_js_namespaceObject.stringValue)(remoteEntry?.type) ?? 'module';
+    const expose = remoteOverride.expose ?? (0, universal_namespaceObject.backendFederationExposeNames)(backendFederation)[0] ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(remoteName, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare a remote name.');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(remoteEntryUrl, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare a backend remote entry URL.');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(expose === external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE, 'manifest_invalid', `[BFF][Effect] Backend federation manifest expose must be ${external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE}.`);
+    return {
+        name: remoteName,
+        entry: remoteEntryUrl,
+        type: remoteType,
+        ...remoteOverride.entryGlobalName ? {
+            entryGlobalName: remoteOverride.entryGlobalName
+        } : {},
+        expose,
+        ...remoteOverride.shareScope ? {
+            shareScope: remoteOverride.shareScope
+        } : {}
+    };
+}
+exports.resolveBackendFederationRemoteFromManifest = __webpack_exports__.resolveBackendFederationRemoteFromManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveBackendFederationRemoteFromManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/backend-federation-manifest/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-manifest/validation.js

@@ -0,0 +1,108 @@
+"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__, {
+    classifyLoadError: ()=>classifyLoadError,
+    validateBackendFederationManifest: ()=>validateBackendFederationManifest,
+    validateLoadedBackendFederationContract: ()=>validateLoadedBackendFederationContract
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_backend_federation_js_namespaceObject = require("../backend-federation.js");
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_metadata_js_namespaceObject = require("./metadata.js");
+function resolveExpectedBuildMarker(expected) {
+    if (void 0 !== expected.buildVersion && void 0 !== expected.buildMarker && expected.buildVersion !== expected.buildMarker) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation expected buildVersion/buildMarker mismatch: buildVersion ${expected.buildVersion}, buildMarker ${expected.buildMarker}.`, void 0, {
+        label: 'expected.buildVersion/buildMarker',
+        expected: expected.buildVersion,
+        received: expected.buildMarker
+    });
+    return expected.buildMarker;
+}
+function validateBackendFederationManifest(manifest, expected = {}) {
+    const expectedBuildMarker = resolveExpectedBuildMarker(expected);
+    const backendFederation = (0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest);
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
+    const manifestShape = (0, universal_namespaceObject.validateBackendFederationManifest)(manifest, {
+        expectedContractVersion: false,
+        expectedNodeAdapterVersion: false,
+        validateDeliveryUnit: false
+    });
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(manifestShape.ok, 'manifest_invalid', `[BFF][Effect] Backend federation manifest schema invalid: ${(0, universal_namespaceObject.formatBackendFederationValidationErrors)(manifestShape.errors)}.`);
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)('effect' === backendFederation.runtimeFramework, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare runtimeFramework: "effect".');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(true === backendFederation.strictEffectApproach, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare strictEffectApproach: true.');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(backendFederation.contractVersion), expected.contractVersion ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION, 'manifest contractVersion');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(backendFederation.nodeAdapterVersion), expected.nodeAdapterVersion ?? external_backend_federation_js_namespaceObject.BACKEND_FEDERATION_NODE_ADAPTER_VERSION, 'manifest nodeAdapterVersion');
+    const boundary = (0, external_metadata_js_namespaceObject.versionBoundaryMetadata)(manifest);
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(backendFederation.name) ?? (0, external_metadata_js_namespaceObject.stringValue)(manifest.name) ?? (0, external_metadata_js_namespaceObject.stringValue)(manifest.id), expected.remoteName, 'manifest remoteName');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName), expected.packageName, 'versionBoundary.packageName');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(boundary?.version), expected.version, 'versionBoundary.version');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), expected.buildVersion, 'versionBoundary.buildVersion');
+    (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(manifest.version), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.version), 'manifest versionBoundary.version');
+    (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(manifest.buildVersion), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'manifest versionBoundary.buildVersion');
+    const deliveryUnit = (0, external_metadata_js_namespaceObject.manifestDeliveryUnit)(backendFederation, boundary);
+    (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'versionBoundary.deliveryUnit.buildMarker vs versionBoundary.buildVersion');
+    (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId), (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId), 'backendFederation.deliveryUnit.unitId vs versionBoundary.deliveryUnit.unitId');
+    const manifestUnitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
+    (0, external_errors_js_namespaceObject.assertVersionValue)(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
+}
+function validateLoadedBackendFederationContract(loaded, manifest, remote) {
+    const loadedContract = loaded.backendFederationContract;
+    const backendFederation = (0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest);
+    const boundary = (0, external_metadata_js_namespaceObject.versionBoundaryMetadata)(manifest);
+    const compatibility = (0, external_metadata_js_namespaceObject.recordField)(loadedContract, 'compatibility');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(compatibility, 'version_mismatch', `[BFF][Effect] Backend federation expose ${remote.name}/${remote.expose?.replace(/^\.\//u, '')} must declare compatibility metadata.`);
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(loadedContract?.role), 'microvertical-server', 'expose role');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(loadedContract?.name), remote.name, 'expose name');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.contractVersion), (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.contractVersion), 'expose contractVersion');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.nodeAdapterVersion), (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.nodeAdapterVersion), 'expose nodeAdapterVersion');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.packageName), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName), 'expose packageName');
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'expose buildVersion');
+    const deliveryUnit = (0, external_metadata_js_namespaceObject.manifestDeliveryUnit)(backendFederation, boundary);
+    const manifestUnitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
+    const manifestBuildMarker = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker);
+    (0, external_errors_js_namespaceObject.assertConsistentValue)(manifestUnitId, (0, external_metadata_js_namespaceObject.stringValue)(compatibility.unitId), 'deliveryUnit.unitId vs expose compatibility.unitId');
+    (0, external_errors_js_namespaceObject.assertConsistentValue)(manifestBuildMarker, (0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), 'deliveryUnit.buildMarker vs expose compatibility.build');
+}
+function classifyLoadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes('strictEffectApproach') || message.includes('runtimeFramework')) return 'strict_effect_required';
+    return 'remote_unavailable';
+}
+exports.classifyLoadError = __webpack_exports__.classifyLoadError;
+exports.validateBackendFederationManifest = __webpack_exports__.validateBackendFederationManifest;
+exports.validateLoadedBackendFederationContract = __webpack_exports__.validateLoadedBackendFederationContract;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "classifyLoadError",
+    "validateBackendFederationManifest",
+    "validateLoadedBackendFederationContract"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});