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

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

@@ -1,41 +0,0 @@
-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/runtime/effect/backend-federation/load.mjs

@@ -1,37 +0,0 @@
-import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "@modern-js/utils/universal";
-import { formatBackendFederationIdentityIssues, validateExpectedBackendFederationIdentity } from "./identity.mjs";
-import { createBackendFederationRuntime } from "./runtime.mjs";
-import { isRecord, normalizeExpose } from "./utils.mjs";
-import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
-import * as __rspack_external_effect_Logger_1691a01b from "effect/Logger";
-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.';
-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();
-    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)=>{
-        if (!isRecord(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must load an object module.`);
-        const backendContract = loaded.backendFederationContract;
-        if (!isRecord(backendContract) || true !== backendContract.strictEffectApproach) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (strictEffectApproach: true).`);
-        if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
-        if ('string' == typeof backendContract.name && backendContract.name !== remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} metadata name mismatch: expected ${remoteName}, received ${backendContract.name}.`);
-        if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose api and runtime.`);
-        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 ${remoteRequest} delivery-unit identity mismatch: ${formatBackendFederationIdentityIssues(issues)}.`);
-        }
-        return loaded;
-    });
-}
-export { loadBackendFederatedEffectApi };

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

@@ -1,25 +0,0 @@
-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/runtime/effect/backend-federation/remotes.mjs

@@ -1,13 +0,0 @@
-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/runtime/effect/backend-federation/runtime.mjs

@@ -1,90 +0,0 @@
-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/runtime/effect/backend-federation/utils.mjs

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

package/dist/esm/runtime/effect/backend-federation-manifest/errors.mjs

@@ -1,32 +0,0 @@
-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/runtime/effect/backend-federation-manifest/index.mjs

@@ -1,4 +0,0 @@
-export { BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT, BackendFederationManifestAdapterError } from "./errors.mjs";
-export { loadBackendFederatedEffectApiFromManifest } from "./load.mjs";
-export { loadBackendFederationManifest } from "./reference.mjs";
-export { resolveBackendFederationRemoteFromManifest } from "./remote.mjs";

package/dist/esm/runtime/effect/backend-federation-manifest/load.mjs

@@ -1,56 +0,0 @@
-import { createInstance } from "@module-federation/runtime";
-import { BACKEND_FEDERATION_EFFECT_EXPOSE, loadBackendFederatedEffectApi } from "../backend-federation.mjs";
-import { BackendFederationManifestAdapterError } from "./errors.mjs";
-import { loadBackendFederationManifest, resolveBackendFederationManifestReference, withTimeout } from "./reference.mjs";
-import { resolveBackendFederationRemoteFromManifest } from "./remote.mjs";
-import { classifyLoadError, validateBackendFederationManifest, validateLoadedBackendFederationContract } from "./validation.mjs";
-async function loadBackendFederatedEffectApiFromManifest(options) {
-    let manifest;
-    let remote;
-    try {
-        manifest = await loadBackendFederationManifest(options);
-        validateBackendFederationManifest(manifest, options.expected);
-        remote = resolveBackendFederationRemoteFromManifest(manifest, options.remote);
-        const manifestReference = resolveBackendFederationManifestReference(options);
-        const officialRuntime = manifestReference && /^https?:\/\//iu.test(manifestReference) && void 0 === options.manifest && void 0 === options.manifestPath && void 0 === options.fetch && void 0 === options.plugins && void 0 === options.remote && void 0 === options.runtime ? createInstance({
-            name: options.hostName,
-            remotes: [
-                {
-                    name: remote.name,
-                    entry: manifestReference
-                }
-            ]
-        }) : void 0;
-        const loaded = await withTimeout(loadBackendFederatedEffectApi({
-            hostName: options.hostName,
-            remote,
-            ...options.plugins ? {
-                plugins: options.plugins
-            } : {},
-            ...options.runtime ? {
-                runtime: options.runtime
-            } : officialRuntime ? {
-                runtime: officialRuntime
-            } : {},
-            ...options.expected?.unitId && options.expected.buildMarker ? {
-                expected: {
-                    unitId: options.expected.unitId,
-                    buildMarker: options.expected.buildMarker
-                },
-                allowMissingIdentityMetadata: true
-            } : {}
-        }), options.timeoutMs, `Backend federation remote ${remote.name}`).catch((error)=>{
-            throw new BackendFederationManifestAdapterError(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 = 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;
-    }
-}
-export { loadBackendFederatedEffectApiFromManifest };

package/dist/esm/runtime/effect/backend-federation-manifest/metadata.mjs

@@ -1,42 +0,0 @@
-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/runtime/effect/backend-federation-manifest/reference.mjs

@@ -1,76 +0,0 @@
-import { BACKEND_FEDERATION_MANIFEST_FILE } from "../backend-federation.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 || options.allowLegacyManifest) 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. 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 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));
-    try {
-        const source = isHttpUrl(reference) ? await (async ()=>{
-            const fetchManifest = options.fetch ?? globalThis.fetch;
-            if (!fetchManifest) throw new 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 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);
-        assertManifestAdapter(isRecord(manifest), 'manifest_invalid', `[BFF][Effect] Backend federation manifest ${reference} must be a JSON object.`);
-        return manifest;
-    } catch (error) {
-        if (error instanceof BackendFederationManifestAdapterError) throw error;
-        throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} could not be loaded.`, error);
-    }
-}
-export { loadBackendFederationManifest, resolveBackendFederationManifestReference, withTimeout };

package/dist/esm/runtime/effect/backend-federation-manifest/remote.mjs

@@ -1,30 +0,0 @@
-import { backendFederationExposeNames } from "@modern-js/utils/universal";
-import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "../backend-federation.mjs";
-import { 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 remoteEntryUrl = remoteOverride.entry ?? stringValue(backendFederation?.containerEntry) ?? stringValue(entry?.url) ?? resolveRemoteEntryFromMetadata(manifest);
-    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;
-    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,
-        ...remoteOverride.entryGlobalName ? {
-            entryGlobalName: remoteOverride.entryGlobalName
-        } : {},
-        expose,
-        ...remoteOverride.shareScope ? {
-            shareScope: remoteOverride.shareScope
-        } : {}
-    };
-}
-export { resolveBackendFederationRemoteFromManifest };

package/dist/esm/runtime/effect/backend-federation-manifest/validation.mjs

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

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

@@ -1 +0,0 @@
-export * from "./backend-federation-manifest/index.mjs";

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

@@ -1,5 +0,0 @@
-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 "./backend-federation/identity.mjs";
-export { loadBackendFederatedEffectApi } from "./backend-federation/load.mjs";
-export { createBackendFederationLoadEntryPlugin } from "./backend-federation/plugin.mjs";
-export { createBackendFederationRuntime } from "./backend-federation/runtime.mjs";

package/dist/esm/runtime/effect/context.mjs

@@ -1,13 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
-const globalStore = globalThis;
-const effectContextStorage = globalStore[kEffectContextStorage] ?? (globalStore[kEffectContextStorage] = new AsyncLocalStorage());
-const runWithEffectContext = (context, cb)=>effectContextStorage.run(context, cb);
-const useEffectContext = ()=>{
-    const context = effectContextStorage.getStore();
-    if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
-    return context;
-};
-const useOperationContext = ()=>useEffectContext().operationContext;
-export { createEffectOperationContext } from "./operation-context.mjs";
-export { runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm/runtime/effect/dispatch.mjs

@@ -1,63 +0,0 @@
-import { createSafeFailureResponse } from "../safe-failure.mjs";
-import { createEffectOperationContext } from "./operation-context.mjs";
-function normalizeEffectBffPrefix(prefix) {
-    if (!prefix || '/' === prefix) return '';
-    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-}
-function removeEffectBffPrefixFromPath(pathname, prefix) {
-    const normalized = normalizeEffectBffPrefix(prefix);
-    if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
-    const sliced = pathname.slice(normalized.length);
-    return sliced.startsWith('/') ? sliced : `/${sliced}`;
-}
-function matchesEffectBffPrefix(pathname, prefix) {
-    const normalized = normalizeEffectBffPrefix(prefix);
-    return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
-}
-function createEffectBffMountedRequest(req, prefix) {
-    const url = new URL(req.url);
-    const nextPath = removeEffectBffPrefixFromPath(url.pathname, prefix);
-    if (nextPath !== url.pathname) {
-        url.pathname = nextPath;
-        return new Request(url, req);
-    }
-    return req;
-}
-function createEffectBffDispatchContext(originalRequest, mountedRequest, options) {
-    const path = options.path ?? new URL(originalRequest.url).pathname;
-    const method = options.method ?? originalRequest.method;
-    const env = options.env ?? {};
-    return {
-        request: mountedRequest,
-        env,
-        path,
-        method,
-        operationContext: createEffectOperationContext({
-            request: mountedRequest,
-            env,
-            path,
-            method
-        })
-    };
-}
-async function dispatchEffectBffRequestWithContext(handler, request, options) {
-    const requestPath = new URL(request.url).pathname;
-    if (!matchesEffectBffPrefix(requestPath, options.prefix)) return new Response('', {
-        status: 404
-    });
-    const mountedRequest = createEffectBffMountedRequest(request, options.prefix);
-    const effectContext = createEffectBffDispatchContext(request, mountedRequest, options);
-    try {
-        const response = await options.runWithEffectContext(effectContext, ()=>handler(mountedRequest, effectContext));
-        if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return Response instance.');
-        return new Response(response.body, response);
-    } catch (error) {
-        if (error instanceof Response) return new Response(error.body, error);
-        if (options.onError) {
-            const errorResponse = await options.onError(error, effectContext);
-            if (errorResponse instanceof Response) return errorResponse;
-        }
-        return createSafeFailureResponse(error);
-    }
-}
-export { dispatchEffectBffRequestWithContext };