@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.28 → 3.5.0-ultramodern.29

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

@@ -1,70 +1,14 @@
-import { createSafeFailureResponse } from "../safe-failure.mjs";
+import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
 import { runWithEffectContext, useEffectContext, useOperationContext } from "./edge-context.mjs";
 import { resolveEffectBffModuleHandler } from "./module.mjs";
-import { createEffectOperationContext } from "./operation-context.mjs";
 export * from "./handler.mjs";
-function normalizePrefix(prefix) {
-    if (!prefix || '/' === prefix) return '';
-    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-}
-function removePrefixFromPath(pathname, prefix) {
-    const normalized = normalizePrefix(prefix);
-    if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
-    const sliced = pathname.slice(normalized.length);
-    return sliced.startsWith('/') ? sliced : `/${sliced}`;
-}
-function matchesPrefix(pathname, prefix) {
-    const normalized = normalizePrefix(prefix);
-    return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
-}
-function createRequestForMountedPrefix(req, prefix) {
-    const url = new URL(req.url);
-    const nextPath = removePrefixFromPath(url.pathname, prefix);
-    if (nextPath === url.pathname) return req;
-    url.pathname = nextPath;
-    return new Request(url, req);
-}
-function createEdgeEffectContext(originalRequest, effectRequest, options) {
-    const originalPath = options.path || new URL(originalRequest.url).pathname;
-    const method = options.method || originalRequest.method;
-    return {
-        request: effectRequest,
-        env: options.env || {},
-        path: originalPath,
-        method,
-        operationContext: createEffectOperationContext({
-            request: effectRequest,
-            env: options.env || {},
-            path: originalPath,
-            method
-        })
-    };
-}
-function createRuntimeErrorResponse(error) {
-    return createSafeFailureResponse(error);
-}
 async function dispatchEffectBffRequest(handler, request, options = {}) {
-    const requestPathname = new URL(request.url).pathname;
-    if (!matchesPrefix(requestPathname, options.prefix)) return new Response(null, {
-        status: 404
+    return dispatchEffectBffRequestWithContext(handler, request, {
+        ...options,
+        runWithEffectContext: runWithEffectContext
     });
-    const effectRequest = createRequestForMountedPrefix(request, options.prefix);
-    const effectContext = createEdgeEffectContext(request, effectRequest, options);
-    try {
-        const response = await runWithEffectContext(effectContext, ()=>handler(effectRequest, effectContext));
-        if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return a 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 createRuntimeErrorResponse(error);
-    }
 }
-const createEffectBffTestHandler = createEffectBffEdgeHandler;
-async function createEffectBffEdgeHandler(options) {
+async function createEffectBffEdgeDispatcher(options) {
     const loaded = await resolveEffectBffModuleHandler(options.module, {
         openapi: options.openapi,
         dataPlatform: options.dataPlatform,
@@ -72,7 +16,7 @@ async function createEffectBffEdgeHandler(options) {
     });
     if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export defineEffectBff(...) or a { api, layer } HttpApi module.');
     return {
-        handler: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
+        dispatch: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
                 ...dispatchOptions,
                 prefix: options.prefix,
                 onError: options.onError
@@ -82,4 +26,14 @@ async function createEffectBffEdgeHandler(options) {
         }
     };
 }
-export { createEffectBffEdgeHandler, createEffectBffTestHandler, createEffectOperationContext, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext };
+const createEffectBffTestHandler = createEffectBffEdgeHandler;
+async function createEffectBffEdgeHandler(options) {
+    const dispatcher = await createEffectBffEdgeDispatcher(options);
+    return {
+        handler: dispatcher.dispatch,
+        dispose: dispatcher.dispose
+    };
+}
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi } from "./backend-federation.mjs";
+export { createEffectOperationContext } from "./operation-context.mjs";
+export { createEffectBffEdgeDispatcher, createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm/runtime/effect/endpoint-contracts.mjs

@@ -1,4 +1,5 @@
 import { createOperationContractHash } from "@modern-js/bff-core";
+import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
 function ensureLeadingSlash(pathname) {
     return pathname.startsWith('/') ? pathname : `/${pathname}`;
 }
@@ -48,19 +49,13 @@ function createEffectOperationContractSource(endpoint) {
         routePath: endpoint.routePath
     };
 }
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
 async function extractHttpApiFromModule(mod, isHttpApi) {
-    if (!isRecord(mod)) return null;
-    if (isHttpApi(mod.api)) return mod.api;
-    const entry = mod.default;
-    if (isRecord(entry) && isHttpApi(entry.api)) return entry.api;
-    if ('function' == typeof entry && 0 === entry.length) {
-        const output = await entry();
-        if (isRecord(output) && isHttpApi(output.api)) return output.api;
-    }
-    return null;
+    const facts = classifyEffectBffEntryModule(mod, {
+        isRequestHandler: (value)=>'function' == typeof value,
+        isValidatorAwareHandlerFactory: isValidatorAwareHandlerFactory,
+        isHttpApi
+    });
+    return !facts?.legacyShape && facts?.api !== void 0 && facts.hasRuntimeLayer && (void 0 === facts.createHandler || facts.createHandlerValidatorAware) ? facts.api : null;
 }
 function createEffectEndpointContractHash(endpoint, requestId) {
     return createOperationContractHash(createEffectOperationContractSource(endpoint), requestId);

package/dist/esm/runtime/effect/entry-shape.mjs

@@ -0,0 +1,36 @@
+const EFFECT_VALIDATOR_AWARE_FACTORY = Symbol.for('modernjs.effect.validatorAware');
+function isValidatorAwareHandlerFactory(factory) {
+    return Boolean('function' == typeof factory && factory[EFFECT_VALIDATOR_AWARE_FACTORY]);
+}
+const strictEffectApproachMessage = '[BFF][Effect] strictEffectApproach is enforced: Effect API entries export defineEffectBff(...) or { api, layer } HttpApi module. Raw handler exports, default request handlers, unbranded custom createHandler factories not valid Effect API entries.';
+function isEffectEntryRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+function classifyEffectBffEntryModule(value, predicates) {
+    if (!isEffectEntryRecord(value)) return null;
+    const rootModule = value;
+    if (predicates.isRequestHandler(rootModule.handler)) return createEntryShapeFacts(rootModule, predicates, '`handler` export');
+    const defaultEntry = rootModule.default;
+    if (predicates.isRequestHandler(defaultEntry)) return createEntryShapeFacts(rootModule, predicates, 'default request handler');
+    const module = isEffectEntryRecord(defaultEntry) ? {
+        ...rootModule,
+        ...defaultEntry
+    } : rootModule;
+    if (predicates.isRequestHandler(module.handler)) return createEntryShapeFacts(module, predicates, '`handler` export');
+    return createEntryShapeFacts(module, predicates);
+}
+function createEntryShapeFacts(module, predicates, legacyShape) {
+    const createHandler = 'function' == typeof module.createHandler ? module.createHandler : void 0;
+    const api = predicates.isHttpApi(module.api) ? module.api : void 0;
+    const hasRuntimeLayer = void 0 !== module.layer;
+    return {
+        module,
+        legacyShape,
+        createHandler,
+        createHandlerValidatorAware: void 0 !== createHandler && predicates.isValidatorAwareHandlerFactory(createHandler),
+        api,
+        layer: module.layer,
+        hasRuntimeLayer
+    };
+}
+export { EFFECT_VALIDATOR_AWARE_FACTORY, classifyEffectBffEntryModule, isEffectEntryRecord, isValidatorAwareHandlerFactory, strictEffectApproachMessage };

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

@@ -3,6 +3,7 @@ import { HttpRouter, HttpServer, HttpServerResponse, HttpTraceContext } from "ef
 import { HttpApiBuilder, OpenApi } from "effect/unstable/httpapi";
 import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
 import { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, decodeRequestEnvelopeHeader, validateRequestEnvelope, validateSelectionPlan } from "../data-platform/index.mjs";
+import { EFFECT_VALIDATOR_AWARE_FACTORY, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
 import * as __rspack_external_effect_Config_29be8a92 from "effect/Config";
 import * as __rspack_external_effect_Effect_194ac36c from "effect/Effect";
 import * as __rspack_external_effect_Option_4d691636 from "effect/Option";
@@ -14,10 +15,6 @@ import * as __rspack_external_effect_Context_f1289ca3 from "effect/Context";
 const emptyEffectServiceContext = __rspack_external_effect_Context_f1289ca3.empty();
 const isEffectServiceContext = (context)=>'object' == typeof context && null !== context && 'mapUnsafe' in context;
 const toEffectServiceContext = (context)=>isEffectServiceContext(context) ? context : emptyEffectServiceContext;
-const EFFECT_VALIDATOR_AWARE_FACTORY = Symbol.for('modernjs.effect.validatorAware');
-function isValidatorAwareHandlerFactory(factory) {
-    return 'function' == typeof factory && true === factory[EFFECT_VALIDATOR_AWARE_FACTORY];
-}
 function normalizeOpenApiPath(pathname) {
     if (!pathname.startsWith('/')) return `/${pathname}`;
     return pathname;

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

@@ -1,5 +1,8 @@
 import * as __rspack_external__effect_opentelemetry_8bbbb5af from "@effect/opentelemetry";
+export * from "./backend-federation.mjs";
 export * from "./handler.mjs";
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi } from "./backend-federation.mjs";
+export { BackendFederationManifestAdapterError, loadBackendFederatedEffectApiFromManifest, loadBackendFederationManifest, resolveBackendFederationRemoteFromManifest } from "./backend-federation-manifest.mjs";
 export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext } from "./context.mjs";
 export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest } from "./edge.mjs";
 export { __rspack_external__effect_opentelemetry_8bbbb5af as OpenTelemetry };

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

@@ -1,23 +1,14 @@
 import { HttpApi } from "effect/unstable/httpapi";
-import { createHttpApiHandler, isValidatorAwareHandlerFactory } from "./handler.mjs";
+import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, strictEffectApproachMessage } from "./entry-shape.mjs";
+import { createHttpApiHandler } from "./handler.mjs";
 import * as __rspack_external_effect_Context_f1289ca3 from "effect/Context";
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function includesRuntimeExports(value) {
-    return 'api' in value || 'layer' in value || 'createHandler' in value || 'handler' in value;
-}
 function isRequestHandler(value) {
     return 'function' == typeof value;
 }
-function isEffectApiDefinition(module) {
-    return HttpApi.isHttpApi(module.api) && void 0 !== module.layer;
-}
 function isEffectServiceContext(context) {
     return 'object' == typeof context && null !== context && 'mapUnsafe' in context;
 }
 const emptyEffectServiceContext = __rspack_external_effect_Context_f1289ca3.empty();
-const strictEffectApproachMessage = '[BFF][Effect] strictEffectApproach is enforced: Effect API entries must export defineEffectBff(...) or a { api, layer } HttpApi module. Raw handler exports, default request handlers, and unbranded custom createHandler factories are not valid Effect API entries.';
 function rejectLegacyEffectModuleShape(options, shape) {
     options.onWarning?.(`${strictEffectApproachMessage} Rejected ${shape}.`);
     return true;
@@ -40,41 +31,21 @@ function createLoadedHttpApiHandler(webHandler) {
         dispose: webHandler.dispose
     };
 }
-function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
-    if (isRequestHandler(normalizedModule.handler)) {
-        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return null;
-        return {
-            handler: normalizedModule.handler
-        };
-    }
-    const entry = normalizedModule.default;
-    if (isRequestHandler(entry)) {
-        if (rejectLegacyEffectModuleShape(options, 'default request handler')) return null;
-        return {
-            handler: entry
-        };
-    }
-    if (isRecord(entry)) normalizedModule = {
-        ...normalizedModule,
-        ...entry
-    };
-    if (isRecord(entry) && 'handler' in entry) {
-        const maybeHandler = entry.handler;
-        if (isRequestHandler(maybeHandler)) normalizedModule = {
-            ...normalizedModule,
-            handler: maybeHandler
-        };
-    }
-    if (isRequestHandler(normalizedModule.handler)) {
-        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return null;
-        return {
-            handler: normalizedModule.handler
-        };
+function classifyEffectBffRuntimeEntryShape(module) {
+    return classifyEffectBffEntryModule(module, {
+        isRequestHandler: isRequestHandler,
+        isValidatorAwareHandlerFactory: isValidatorAwareHandlerFactory,
+        isHttpApi: HttpApi.isHttpApi
+    });
+}
+function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
+    if (!facts) return null;
+    if (facts.legacyShape) {
+        if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) return null;
     }
-    if ('function' == typeof normalizedModule.createHandler) {
-        const factory = normalizedModule.createHandler;
-        const validatorAware = isValidatorAwareHandlerFactory(factory);
-        if (!validatorAware && rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export')) return null;
+    if ('function' == typeof facts.createHandler) {
+        if (!facts.createHandlerValidatorAware && rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export')) return null;
+        const factory = facts.createHandler;
         const webHandler = factory({
             openapi: options.openapi,
             dataPlatform: options.dataPlatform,
@@ -82,11 +53,11 @@ function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {})
         });
         return createLoadedHandler(webHandler);
     }
-    if (isEffectApiDefinition(normalizedModule)) {
+    if (void 0 !== facts.api && facts.hasRuntimeLayer) {
         options.onWarning?.('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/plugin-bff/server to avoid module instance mismatch.');
         const webHandler = createHttpApiHandler({
-            api: normalizedModule.api,
-            layer: normalizedModule.layer,
+            api: facts.api,
+            layer: facts.layer,
             openapi: options.openapi,
             dataPlatform: options.dataPlatform,
             validateRequest: options.validateRequest
@@ -95,38 +66,10 @@ function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {})
     }
     return null;
 }
+function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
+    return resolveClassifiedEffectBffModuleHandler(classifyEffectBffRuntimeEntryShape(normalizedModule), options);
+}
 function resolveEffectBffModuleHandler(mod, options = {}) {
-    let normalizedModule = mod;
-    const mergeRuntimeExports = (value)=>{
-        if (!isRecord(value) || !includesRuntimeExports(value)) return;
-        normalizedModule = {
-            ...normalizedModule,
-            ...value
-        };
-    };
-    if (isRequestHandler(normalizedModule.handler)) {
-        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return Promise.resolve(null);
-        return Promise.resolve({
-            handler: normalizedModule.handler
-        });
-    }
-    const entry = normalizedModule.default;
-    if (isRequestHandler(entry)) {
-        if (rejectLegacyEffectModuleShape(options, 'default request handler')) return Promise.resolve(null);
-        return Promise.resolve({
-            handler: entry
-        });
-    }
-    if ('function' == typeof entry && 0 === entry.length) return Promise.resolve(entry()).then((out)=>{
-        if (isRequestHandler(out)) {
-            if (rejectLegacyEffectModuleShape(options, 'default factory returning a request handler')) return null;
-            return {
-                handler: out
-            };
-        }
-        mergeRuntimeExports(out);
-        return resolveNormalizedEffectBffModuleHandler(normalizedModule, options);
-    });
-    return Promise.resolve(resolveNormalizedEffectBffModuleHandler(normalizedModule, options));
+    return Promise.resolve(resolveNormalizedEffectBffModuleHandler(mod, options));
 }
 export { resolveEffectBffModuleHandler };

package/dist/esm-node/runtime/effect/adapter.mjs

@@ -5,7 +5,8 @@ import { HttpApi } from "effect/unstable/httpapi";
 import path from "path";
 import { checkCrossProjectPolicyForRequest, resolveAdapterCrossProjectPolicy } from "../../utils/crossProjectServerPolicy.mjs";
 import { createSafeFailureResponse } from "../safe-failure.mjs";
-import { createEffectOperationContext, runWithEffectContext } from "./context.mjs";
+import { runWithEffectContext } from "./context.mjs";
+import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
 import { collectEffectEndpoints, extractHttpApiFromModule, toOperationContractSources } from "./endpoint-contracts.mjs";
 import { resolveEffectBffModuleHandler } from "./module.mjs";
 const before = [
@@ -28,26 +29,6 @@ function resolveJsOrTsEntry(entryWithoutOrWithExt) {
     if (JS_OR_TS_EXTS.includes(extension)) return fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
     return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutOrWithExt}${ext}`));
 }
-function normalizePrefix(prefix) {
-    if ('/' === prefix) return '';
-    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-}
-function removePrefixFromPath(pathname, prefix) {
-    const normalized = normalizePrefix(prefix);
-    if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
-    const sliced = pathname.slice(normalized.length);
-    return sliced.startsWith('/') ? sliced : `/${sliced}`;
-}
-function createRequestForMountedPrefix(req, prefix) {
-    const url = new URL(req.url);
-    const nextPath = removePrefixFromPath(url.pathname, prefix);
-    if (nextPath === url.pathname) return req;
-    url.pathname = nextPath;
-    return new Request(url, req);
-}
-function maybeResponse(value) {
-    return value instanceof Response;
-}
 class EffectAdapter {
     resolveEntryFile() {
         const { appDirectory, apiDirectory } = this.api.getServerContext();
@@ -193,26 +174,14 @@ class EffectAdapter {
                         if (enableHandleWeb) return void await next();
                         return this.handleRuntimeError(new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), c);
                     }
-                    let response;
-                    try {
-                        const effectRequest = createRequestForMountedPrefix(c.req.raw, prefix);
-                        const effectContext = {
-                            request: effectRequest,
-                            env: c.env,
-                            path: c.req.path,
-                            method: c.req.method,
-                            operationContext: createEffectOperationContext({
-                                request: effectRequest,
-                                env: c.env,
-                                path: c.req.path,
-                                method: c.req.method
-                            })
-                        };
-                        response = await runWithEffectContext(effectContext, ()=>this.handler.length > 1 ? this.handler(effectRequest, effectContext) : this.handler(effectRequest));
-                    } catch (error) {
-                        return this.handleRuntimeError(error, c);
-                    }
-                    if (!maybeResponse(response)) return this.handleRuntimeError(new Error('[BFF][Effect] Effect handler must return a Response instance.'), c);
+                    const response = await dispatchEffectBffRequestWithContext(this.handler, c.req.raw, {
+                        prefix,
+                        env: c.env,
+                        path: c.req.path,
+                        method: c.req.method,
+                        runWithEffectContext: runWithEffectContext,
+                        onError: (error)=>this.handleRuntimeError(error, c)
+                    });
                     if (404 === response.status && enableHandleWeb) return void await next();
                     return new Response(response.body, response);
                 }

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

@@ -0,0 +1,238 @@
+import "node:module";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, loadBackendFederatedEffectApi } from "./backend-federation.mjs";
+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 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 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
+    });
+}
+function getProcessEnv() {
+    return "u" > typeof process ? process.env : void 0;
+}
+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 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);
+    }
+}
+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 recordField(manifest, 'backendFederation');
+}
+function versionBoundaryMetadata(manifest) {
+    return recordField(backendFederationMetadata(manifest), 'versionBoundary');
+}
+function deliveryUnitMetadata(record) {
+    return recordField(record, 'deliveryUnit');
+}
+function manifestDeliveryUnit(backendFederation, boundary) {
+    return {
+        boundary: deliveryUnitMetadata(boundary),
+        top: deliveryUnitMetadata(backendFederation)
+    };
+}
+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 validateBackendFederationManifest(manifest, expected = {}) {
+    const expectedBuildMarker = resolveExpectedBuildMarker(expected);
+    const backendFederation = backendFederationMetadata(manifest);
+    assertManifestAdapter(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
+    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('strictEffectApproach') || message.includes('runtimeFramework')) return 'strict_effect_required';
+    return 'remote_unavailable';
+}
+async function loadBackendFederationManifest(options) {
+    if (options.manifest) return options.manifest;
+    const reference = resolveManifestReference(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}.`);
+    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);
+    }
+}
+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 ?? stringValue(backendFederation?.expose) ?? 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
+        } : {}
+    };
+}
+async function loadBackendFederatedEffectApiFromManifest(options) {
+    let manifest;
+    let remote;
+    try {
+        manifest = await loadBackendFederationManifest(options);
+        validateBackendFederationManifest(manifest, options.expected);
+        remote = resolveBackendFederationRemoteFromManifest(manifest, options.remote);
+        const loaded = await withTimeout(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 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 { BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT, BackendFederationManifestAdapterError, loadBackendFederatedEffectApiFromManifest, loadBackendFederationManifest, resolveBackendFederationRemoteFromManifest };