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

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

@@ -0,0 +1,140 @@
+import "node:module";
+import node_path from "node:path";
+import { dispatchEffectBffRequest, resolveEffectBffModuleHandler, useEffectContext } from "@modern-js/bff-effect/effect";
+import { createDisposableServerRuntimeHandle, registerServerRuntimeDisposer } from "@modern-js/server-runtime-extensions/runtime-lifecycle";
+import { fs, isProd, logger } from "@modern-js/utils";
+import { checkCrossProjectPolicyForRequest } from "../cross-project-policy/evaluation.mjs";
+import { loadEffectBuiltModule, loadEffectSourceModule } from "../effect-source-loader/loader.mjs";
+import { resolveEffectAdapterCrossProjectPolicy } from "./cross-project-policy.mjs";
+import { resolveEffectAdapterEntryFile } from "./entry.mjs";
+import { createEffectAdapterRuntimeErrorResponse } from "./error-response.mjs";
+const EFFECT_MIDDLEWARE_BEFORE = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+class EffectAdapter {
+    async loadHandler() {
+        const entryFile = resolveEffectAdapterEntryFile(this.api);
+        if (!entryFile || !await fs.pathExists(entryFile)) {
+            this.handler = null;
+            return;
+        }
+        let mod;
+        try {
+            const { appDirectory } = this.api.getServerContext();
+            mod = await (isProd() ? loadEffectBuiltModule(entryFile) : loadEffectSourceModule({
+                resourcePath: entryFile,
+                appDir: appDirectory || node_path.dirname(entryFile)
+            }));
+        } catch (error) {
+            logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
+            throw error;
+        }
+        const crossProjectPolicies = new Map(await Promise.all(this.prefixes.map(async (prefix)=>[
+                prefix,
+                await resolveEffectAdapterCrossProjectPolicy(this.api, prefix, mod)
+            ])));
+        const effectConfig = this.api.getServerConfig()?.bff?.effect;
+        const loaded = await resolveEffectBffModuleHandler(mod, {
+            openapi: effectConfig?.openapi,
+            dataPlatform: effectConfig?.dataPlatform,
+            validateRequest: (request)=>{
+                const { path: mountedPathname } = useEffectContext();
+                const prefix = this.matchingPrefixes.find((item)=>'/' === item || mountedPathname === item || mountedPathname.startsWith(`${item}/`));
+                if (!prefix) return null;
+                const requestUrl = new URL(request.url);
+                if ('/' !== prefix) requestUrl.pathname = '/' === requestUrl.pathname ? prefix : `${prefix}${requestUrl.pathname}`;
+                return checkCrossProjectPolicyForRequest(new Request(requestUrl, request), crossProjectPolicies.get(prefix));
+            },
+            onWarning: (message)=>logger.warn(message)
+        });
+        if (!loaded) {
+            const error = new Error(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
+            logger.warn(error.message);
+            throw error;
+        }
+        const candidateOwner = {};
+        if (loaded.dispose) registerServerRuntimeDisposer(candidateOwner, loaded.dispose);
+        const candidate = createDisposableServerRuntimeHandle(candidateOwner, loaded.handler);
+        if (this.retired) {
+            await candidate.dispose();
+            throw new Error('Cannot initialize a retired Effect adapter.');
+        }
+        this.handler = candidate;
+    }
+    constructor(api){
+        this.handler = null;
+        this.prefix = '/api';
+        this.prefixes = [
+            '/api'
+        ];
+        this.matchingPrefixes = [
+            '/api'
+        ];
+        this.retired = false;
+        this.registerMiddleware = async (options)=>{
+            const { enableHandleWeb } = options;
+            const { bffRuntimeFramework, middlewares: globalMiddlewares } = this.api.getServerContext();
+            if ('hono' === bffRuntimeFramework) return;
+            const configuredPrefixes = Array.isArray(options.prefix) ? options.prefix.filter(Boolean) : [
+                options.prefix || '/api'
+            ];
+            this.prefixes = [
+                ...new Set(configuredPrefixes.length > 0 ? configuredPrefixes : [
+                    '/api'
+                ])
+            ];
+            this.matchingPrefixes = [
+                ...this.prefixes
+            ].sort((left, right)=>right.length - left.length);
+            this.prefix = this.prefixes[0] || '/api';
+            const { serverBase } = this.api.getServerContext();
+            if (serverBase) this.unregisterRuntimeDisposer = registerServerRuntimeDisposer(serverBase, this.dispose);
+            try {
+                await this.loadHandler();
+            } catch (error) {
+                await this.dispose();
+                throw error;
+            }
+            const middlewarePrefixes = enableHandleWeb ? [
+                this.prefix
+            ] : this.matchingPrefixes;
+            const middlewares = middlewarePrefixes.map((middlewarePrefix)=>({
+                    name: 'effect-api-handler',
+                    path: enableHandleWeb ? '*' : `${middlewarePrefix}/*`,
+                    method: 'all',
+                    order: 'post',
+                    before: EFFECT_MIDDLEWARE_BEFORE,
+                    handler: async (context, next)=>{
+                        const handler = this.handler;
+                        if (!handler) {
+                            if (enableHandleWeb) return void await next();
+                            return createEffectAdapterRuntimeErrorResponse(this.api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), context);
+                        }
+                        const prefix = enableHandleWeb ? this.matchingPrefixes.find((item)=>'/' === item || context.req.path === item || context.req.path.startsWith(`${item}/`)) || this.prefix : middlewarePrefix;
+                        const response = await dispatchEffectBffRequest(handler, context.req.raw, {
+                            prefix,
+                            env: context.env,
+                            path: context.req.path,
+                            method: context.req.method,
+                            onError: (error)=>createEffectAdapterRuntimeErrorResponse(this.api, error, context)
+                        });
+                        if (404 === response.status && enableHandleWeb) return void await next();
+                        return new Response(response.body, response);
+                    }
+                }));
+            globalMiddlewares.push(...middlewares);
+        };
+        this.dispose = async ()=>{
+            this.retired = true;
+            this.unregisterRuntimeDisposer?.();
+            this.unregisterRuntimeDisposer = void 0;
+            const previous = this.handler;
+            this.handler = null;
+            await previous?.dispose();
+        };
+        this.api = api;
+    }
+}
+export { EffectAdapter };

package/dist/esm-node/effect-source-loader/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { resolveEffectEntryFile } from "../client-generator/paths.mjs";
+export { bundleEffectEntryForNode } from "./loader.mjs";
+export { generateEffectClientCode, generateEffectWorkerRuntimeWrapper } from "./worker-runtime-wrapper.mjs";

package/dist/esm-node/effect-source-loader/loader.mjs

@@ -0,0 +1,286 @@
+import "node:module";
+import node_crypto from "node:crypto";
+import node_fs from "node:fs";
+import { builtinModules, createRequire } from "node:module";
+import node_path from "node:path";
+import { pathToFileURL } from "node:url";
+import { build, transform } from "esbuild";
+const NODE_TARGET = 'node26.7';
+const SOURCE_LOADERS = new Map([
+    [
+        '.js',
+        'js'
+    ],
+    [
+        '.jsx',
+        'jsx'
+    ],
+    [
+        '.mjs',
+        'js'
+    ],
+    [
+        '.cjs',
+        'js'
+    ],
+    [
+        '.ts',
+        'ts'
+    ],
+    [
+        '.tsx',
+        'tsx'
+    ],
+    [
+        '.mts',
+        'ts'
+    ],
+    [
+        '.cts',
+        'ts'
+    ]
+]);
+function sourceLoader(args) {
+    return SOURCE_LOADERS.get(node_path.extname(args.path).toLowerCase());
+}
+function preserveSourceModuleSemantics() {
+    return {
+        name: 'modern-js-effect-source-semantics',
+        setup (buildApi) {
+            buildApi.onLoad({
+                filter: /\.[cm]?[jt]sx?$/
+            }, async (args)=>{
+                const loader = sourceLoader(args);
+                if (!loader) return;
+                const source = await node_fs.promises.readFile(args.path, 'utf8');
+                const compiled = await transform(source, {
+                    define: {
+                        'import.meta.url': JSON.stringify(pathToFileURL(args.path).href)
+                    },
+                    jsx: 'automatic',
+                    loader,
+                    sourcefile: args.path,
+                    target: NODE_TARGET
+                });
+                return {
+                    contents: compiled.code,
+                    loader: 'js',
+                    resolveDir: node_path.dirname(args.path)
+                };
+            });
+        }
+    };
+}
+const nodeBuiltins = new Set([
+    ...builtinModules,
+    ...builtinModules.map((name)=>`node:${name}`)
+]);
+const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+async function isEsmOnlyFile(filename) {
+    const extension = node_path.extname(filename).toLowerCase();
+    if ('.mjs' === extension || '.mts' === extension) return true;
+    if ('.cjs' === extension || '.cts' === extension) return false;
+    let directory = node_path.dirname(filename);
+    while(true){
+        const packagePath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = JSON.parse(await node_fs.promises.readFile(packagePath, 'utf8'));
+            return 'module' === packageJson.type;
+        } catch (error) {
+            if (!error || 'object' != typeof error || !('code' in error) || 'ENOENT' !== error.code) throw error;
+        }
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return false;
+        directory = parent;
+    }
+}
+function isBareSpecifier(specifier) {
+    return !specifier.startsWith('.') && !specifier.startsWith('/') && !node_path.isAbsolute(specifier);
+}
+function externalizeInstalledDependencies(options) {
+    const runtimeRequire = createRequire(node_path.join(options.runtimeResolveDir, '__modern_effect_entry.cjs'));
+    return {
+        name: 'modern-js-effect-installed-dependencies',
+        setup (buildApi) {
+            buildApi.onResolve({
+                filter: /.*/
+            }, async (args)=>{
+                if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
+                    external: true,
+                    path: args.path
+                } : void 0;
+                const resolution = await buildApi.resolve(args.path, {
+                    importer: args.importer,
+                    kind: args.kind,
+                    namespace: args.namespace,
+                    pluginData: {
+                        ...args.pluginData,
+                        [dependencyResolutionMarker]: true
+                    },
+                    resolveDir: args.resolveDir
+                });
+                if (resolution.errors.length > 0) return {
+                    external: true,
+                    path: args.path
+                };
+                if (resolution.external || !resolution.path) return {
+                    external: true,
+                    path: args.path
+                };
+                const realPath = await node_fs.promises.realpath(resolution.path).catch(()=>resolution.path);
+                if (realPath.includes(`${node_path.sep}node_modules${node_path.sep}`)) {
+                    const runtimeResolution = await buildApi.resolve(args.path, {
+                        importer: '',
+                        kind: args.kind,
+                        namespace: 'file',
+                        pluginData: {
+                            [dependencyResolutionMarker]: true
+                        },
+                        resolveDir: options.runtimeResolveDir
+                    });
+                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) {
+                        if ('cjs' === options.format) {
+                            let requiredPath;
+                            try {
+                                requiredPath = runtimeRequire.resolve(args.path);
+                            } catch  {
+                                requiredPath = runtimeResolution.path;
+                            }
+                            if (await isEsmOnlyFile(requiredPath)) return {
+                                namespace: resolution.namespace,
+                                path: resolution.path,
+                                pluginData: resolution.pluginData,
+                                sideEffects: resolution.sideEffects,
+                                suffix: resolution.suffix,
+                                warnings: resolution.warnings
+                            };
+                        }
+                        return {
+                            external: true,
+                            path: args.path
+                        };
+                    }
+                }
+                return {
+                    namespace: resolution.namespace,
+                    path: resolution.path,
+                    pluginData: resolution.pluginData,
+                    sideEffects: resolution.sideEffects,
+                    suffix: resolution.suffix,
+                    warnings: resolution.warnings
+                };
+            });
+        }
+    };
+}
+async function bundleEffectEntryForNode(options) {
+    await build({
+        absWorkingDir: options.appDir,
+        allowOverwrite: true,
+        bundle: true,
+        entryPoints: [
+            options.entryPath
+        ],
+        format: options.format,
+        logLevel: 'silent',
+        outfile: options.entryPath,
+        platform: 'node',
+        plugins: [
+            externalizeInstalledDependencies({
+                format: options.format,
+                runtimeResolveDir: options.appDir
+            }),
+            preserveSourceModuleSemantics()
+        ],
+        target: NODE_TARGET
+    });
+}
+function isWatchableInput(filename) {
+    return !filename.includes(`${node_path.sep}node_modules${node_path.sep}`) && (SOURCE_LOADERS.has(node_path.extname(filename).toLowerCase()) || '.json' === node_path.extname(filename).toLowerCase());
+}
+function normalizeImportedModule(module) {
+    if (!module || 'object' != typeof module) return module;
+    const namespace = module;
+    const commonJsModule = namespace.default;
+    if (1 === Object.keys(namespace).length && null !== commonJsModule && 'object' == typeof commonJsModule && true === commonJsModule.__esModule) return commonJsModule;
+    return module;
+}
+function hasErrorCode(error, code) {
+    return null !== error && 'object' == typeof error && 'code' in error && error.code === code;
+}
+async function publishImmutableOutput(options) {
+    const revision = node_crypto.createHash('sha256').update(options.contents).digest('hex');
+    const outputPath = node_path.join(options.cacheDirectory, `${options.outputName}-${revision}.mjs`);
+    const temporaryPath = node_path.join(options.cacheDirectory, `.${options.outputName}-${node_crypto.randomUUID()}.tmp`);
+    try {
+        await node_fs.promises.writeFile(temporaryPath, options.contents, {
+            flag: 'wx'
+        });
+        try {
+            await node_fs.promises.link(temporaryPath, outputPath);
+        } catch (error) {
+            if (!hasErrorCode(error, 'EEXIST')) throw error;
+            const publishedContents = await node_fs.promises.readFile(outputPath);
+            if (!publishedContents.equals(Buffer.from(options.contents))) throw new Error(`Effect source cache entry does not match its content address: ${outputPath}`);
+        }
+    } finally{
+        await node_fs.promises.rm(temporaryPath, {
+            force: true
+        });
+    }
+    return outputPath;
+}
+async function loadEffectBuiltModule(resourcePath) {
+    const canonicalPath = await node_fs.promises.realpath(node_path.resolve(resourcePath));
+    if (!await isEsmOnlyFile(canonicalPath)) return createRequire(canonicalPath)(canonicalPath);
+    return normalizeImportedModule(await import(pathToFileURL(canonicalPath).href));
+}
+async function loadEffectSourceModule(options) {
+    const resourcePath = node_path.resolve(options.resourcePath);
+    const appDir = node_path.resolve(options.appDir ?? node_path.dirname(resourcePath));
+    const tsconfigPath = node_path.join(appDir, 'tsconfig.json');
+    const cacheDirectory = node_path.join(appDir, 'node_modules', '.cache', 'modern-js', 'effect-source-loader');
+    const outputName = node_crypto.createHash('sha256').update(resourcePath).digest('hex').slice(0, 24);
+    await node_fs.promises.mkdir(cacheDirectory, {
+        recursive: true
+    });
+    const result = await build({
+        absWorkingDir: appDir,
+        banner: {
+            js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify(pathToFileURL(resourcePath).href)});`
+        },
+        bundle: true,
+        entryPoints: [
+            resourcePath
+        ],
+        format: 'esm',
+        jsx: 'automatic',
+        logLevel: 'silent',
+        metafile: true,
+        outfile: node_path.join(cacheDirectory, `${outputName}.mjs`),
+        platform: 'node',
+        plugins: [
+            externalizeInstalledDependencies({
+                format: 'esm',
+                runtimeResolveDir: appDir
+            }),
+            preserveSourceModuleSemantics()
+        ],
+        sourcemap: 'inline',
+        target: NODE_TARGET,
+        tsconfig: node_fs.existsSync(tsconfigPath) ? tsconfigPath : void 0,
+        write: false
+    });
+    for (const input of Object.keys(result.metafile.inputs)){
+        const dependency = node_path.isAbsolute(input) ? node_path.normalize(input) : node_path.resolve(appDir, input);
+        if (isWatchableInput(dependency)) options.onDependency?.(dependency);
+    }
+    if (1 !== result.outputFiles.length) throw new Error(`Expected one Effect source output, received ${result.outputFiles.length}`);
+    const outputPath = await publishImmutableOutput({
+        cacheDirectory,
+        contents: result.outputFiles[0].contents,
+        outputName
+    });
+    return normalizeImportedModule(await import(pathToFileURL(outputPath).href));
+}
+export { bundleEffectEntryForNode, loadEffectBuiltModule, loadEffectSourceModule };

package/dist/esm-node/effect-source-loader/worker-runtime-wrapper.mjs

@@ -0,0 +1,57 @@
+import "node:module";
+async function generateEffectWorkerRuntimeWrapper(loader, options, resourcePath) {
+    const { generateEffectClient } = await import("../client-generator/generator.mjs");
+    const artifacts = await generateEffectClient({
+        appDir: options.appDir,
+        apiDir: options.apiDir,
+        resourcePath,
+        prefix: options.prefix,
+        port: Number(options.port),
+        target: 'bundle',
+        requestId: options.requestId,
+        requestCreator: options.requestCreator,
+        httpMethodDecider: options.httpMethodDecider,
+        dataPlatformBatch: options.effectDataPlatformBatch,
+        onDependency: (dependency)=>loader.addDependency(dependency)
+    });
+    const sourceRequest = `${resourcePath}?modern-bff-runtime-source`;
+    const operationContracts = artifacts?.operationContracts ?? {};
+    return `import * as effectBffModule from ${JSON.stringify(sourceRequest)};
+import { createEffectBffEdgeDispatcher } from '@modern-js/plugin-bff/effect-edge/dispatcher';
+
+const __generatedOperationContracts = ${JSON.stringify(operationContracts)};
+
+const __mergeGeneratedOperationContracts = policy => {
+  if (
+    !policy ||
+    !policy.expectedOperationContracts ||
+    typeof policy.expectedOperationContracts !== 'object' ||
+    Array.isArray(policy.expectedOperationContracts)
+  ) {
+    return policy;
+  }
+  return {
+    ...policy,
+    expectedOperationContracts: {
+      ...policy.expectedOperationContracts,
+      ...__generatedOperationContracts,
+    },
+  };
+};
+
+export const __modern_create_effect_bff_dispatcher = options =>
+  createEffectBffEdgeDispatcher({
+    ...options,
+    crossProjectPolicy: __mergeGeneratedOperationContracts(
+      options?.crossProjectPolicy,
+    ),
+    module: effectBffModule,
+  });
+`;
+}
+async function generateEffectClientCode(options) {
+    const { generateEffectClient } = await import("../client-generator/generator.mjs");
+    const artifacts = await generateEffectClient(options);
+    return null === artifacts ? null : artifacts.code;
+}
+export { generateEffectClientCode, generateEffectWorkerRuntimeWrapper };

package/dist/esm-node/hono/bind-route-handlers.mjs

@@ -0,0 +1,39 @@
+import "node:module";
+import { createSafeFailureResponse } from "@modern-js/runtime-extensions/safe-failure";
+import { createHonoCrossProjectPolicyMiddleware } from "./cross-project-policy.mjs";
+const bindHonoRouteHandlers = ({ handler, policy, routePath, onError, reportError })=>{
+    const handlers = Array.isArray(handler) ? handler : [
+        handler
+    ];
+    const [firstHandler, ...restHandlers] = handlers;
+    let routeHandlers = handler;
+    if (firstHandler) {
+        const errorBoundary = async (context, next)=>{
+            try {
+                return await firstHandler(context, next);
+            } catch (error) {
+                try {
+                    if (onError) {
+                        const result = await onError(error, context);
+                        if (result instanceof Response) return result;
+                    } else reportError?.(error);
+                } catch (configError) {
+                    reportError?.(`Error in serverConfig.onError handler: ${configError}`);
+                }
+                return createSafeFailureResponse(error);
+            }
+        };
+        routeHandlers = Array.isArray(handler) ? [
+            errorBoundary,
+            ...restHandlers
+        ] : errorBoundary;
+    }
+    if (!policy) return routeHandlers;
+    return [
+        createHonoCrossProjectPolicyMiddleware(policy, routePath),
+        ...Array.isArray(routeHandlers) ? routeHandlers : [
+            routeHandlers
+        ]
+    ];
+};
+export { bindHonoRouteHandlers };

package/dist/esm-node/hono/cross-project-policy.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import { checkCrossProjectPolicyResponse } from "../cross-project-policy/evaluation.mjs";
+const createHonoCrossProjectPolicyMiddleware = (policy, routePath)=>async function(context, next) {
+        const denial = checkCrossProjectPolicyResponse(context.req.header(), policy, {
+            method: context.req.method,
+            routePath
+        });
+        if (denial) return denial;
+        return next();
+    };
+export { createHonoCrossProjectPolicyMiddleware };

package/dist/esm-node/hono/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { bindHonoRouteHandlers } from "./bind-route-handlers.mjs";

package/dist/types/backend-federation/edge-runtime.d.ts

@@ -0,0 +1,46 @@
+import type { BackendFederationExpectedIdentity } from './identity';
+import type { BackendFederationEntryExports } from './types';
+export type BackendFederationEdgeLoadEntryPlugin = {
+    name: string;
+    loadEntry: (args: {
+        remoteInfo: BackendFederationEdgeRemote;
+    }) => BackendFederationEntryExports | undefined | Promise<BackendFederationEntryExports | undefined>;
+};
+export type BackendFederationEdgeLoadEntryPluginOptions = {
+    /**
+     * Resolve the fork-owned edge entry contract, not a raw Module Federation
+     * container. The edge runtime calls its optional `init` once per remote with
+     * `{ hostName }`, then caches each loaded expose.
+     */
+    resolveEntry: (remote: BackendFederationEdgeRemote) => BackendFederationEntryExports | undefined | Promise<BackendFederationEntryExports | undefined>;
+};
+export type BackendFederationEdgeRemote = {
+    entry: `${'binding' | 'service' | 'static'}:${string}`;
+    entryGlobalName?: string;
+    expose?: string;
+    name: string;
+    shareScope?: string | string[];
+    type?: 'commonjs-module' | 'module' | string;
+    verification?: never;
+};
+type BackendFederationEdgeRuntimeBaseOptions = {
+    entryPolicy?: never;
+    hostName: string;
+    plugins?: BackendFederationEdgeLoadEntryPlugin[];
+    remote?: BackendFederationEdgeRemote;
+    remotes?: BackendFederationEdgeRemote[];
+};
+export type BackendFederationEdgeRuntimeOptions = BackendFederationEdgeRuntimeBaseOptions & {
+    expected: BackendFederationExpectedIdentity;
+};
+type EdgeRuntimeLoadOptions = BackendFederationEdgeRuntimeBaseOptions & {
+    allowMissingIdentityMetadata?: boolean;
+    expected?: BackendFederationExpectedIdentity;
+};
+export type BackendFederationEdgeRuntime = {
+    loadRemote<T>(request: string): Promise<T>;
+};
+export declare function createBackendFederationLoadEntryPlugin(options: BackendFederationEdgeLoadEntryPluginOptions): BackendFederationEdgeLoadEntryPlugin;
+export declare function createBackendFederationRuntime(options: BackendFederationEdgeRuntimeOptions): BackendFederationEdgeRuntime;
+export declare function createBackendFederationRuntimeForLoad(options: EdgeRuntimeLoadOptions): BackendFederationEdgeRuntime;
+export {};

package/dist/types/backend-federation/edge.d.ts

@@ -0,0 +1,28 @@
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from '@modern-js/utils/universal';
+import { type BackendFederationEdgeLoadEntryPlugin, type BackendFederationEdgeLoadEntryPluginOptions, type BackendFederationEdgeRemote, type BackendFederationEdgeRuntimeOptions } from './edge-runtime';
+import type { BackendFederatedEffectApiModule, BackendFederationLoadOptions, BackendFederationIdentityLoadOptions as UniversalBackendFederationIdentityLoadOptions } from './types';
+export { type BackendFederationEdgeLoadEntryPlugin, type BackendFederationEdgeLoadEntryPluginOptions, type BackendFederationEdgeRemote, type BackendFederationEdgeRuntime, type BackendFederationEdgeRuntimeOptions, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, } from './edge-runtime';
+export { type BackendFederationExpectedIdentity, type BackendFederationIdentityIssue, validateExpectedBackendFederationIdentity, } from './identity';
+export type { BackendFederatedEffectApiModule, BackendFederationEntryExports, } from './types';
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, };
+export type BackendFederationRemote = BackendFederationEdgeRemote;
+export type BackendFederationRuntimeOptions = BackendFederationEdgeRuntimeOptions;
+export type BackendFederationLoadEntryPluginOptions = BackendFederationEdgeLoadEntryPluginOptions;
+export type EdgeBackendFederationLoadOptions = Omit<BackendFederationLoadOptions, 'entryPolicy' | 'plugins' | 'remote' | 'remotes' | 'runtime'> & {
+    entryPolicy?: never;
+    plugins?: BackendFederationEdgeLoadEntryPlugin[];
+    remote?: BackendFederationEdgeRemote;
+    remotes?: BackendFederationEdgeRemote[];
+    runtime?: never;
+};
+export type EdgeBackendFederationIdentityLoadOptions = Omit<UniversalBackendFederationIdentityLoadOptions, 'entryPolicy' | 'plugins' | 'remote' | 'remotes' | 'runtime'> & {
+    entryPolicy?: never;
+    plugins?: BackendFederationEdgeLoadEntryPlugin[];
+    remote?: BackendFederationEdgeRemote;
+    remotes?: BackendFederationEdgeRemote[];
+    runtime?: never;
+};
+export type BackendFederationIdentityLoadOptions = EdgeBackendFederationIdentityLoadOptions;
+export declare function loadBackendFederatedEffectApi(options: EdgeBackendFederationIdentityLoadOptions): Promise<BackendFederatedEffectApiModule>;
+/** @deprecated Pass `expected` delivery-unit identity. */
+export declare function loadBackendFederatedEffectApi(options: EdgeBackendFederationLoadOptions): Promise<BackendFederatedEffectApiModule>;

package/dist/types/backend-federation/entry.d.ts

@@ -0,0 +1,2 @@
+import type { BackendFederationRemote, BackendFederationRuntimeOptions } from './types';
+export declare function loadBackendFederationExpose(remote: BackendFederationRemote, expose: string, options: BackendFederationRuntimeOptions): Promise<unknown>;

package/dist/types/backend-federation/identity.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Mandatory delivery-unit identity for public backend federation loads
+ * (MV-G23, ADR-0019 / RESOLUTION-0001 §2.3): consumers pass the record's
+ * `unitId` + `buildMarker` through to identity validation.
+ */
+export type BackendFederationExpectedIdentity = {
+    unitId: string;
+    buildMarker: string;
+};
+export type BackendFederationIdentityIssue = {
+    path: string;
+    message: string;
+};
+/**
+ * Shared expected-identity validation for loaded backend federation modules.
+ * Compares the expose's `backendFederationContract.compatibility` identity
+ * (`unitId`, `build`) against the consumer's expected delivery-unit identity.
+ * Missing identity metadata is an error: with an expectation present there is
+ * no legacy escape hatch.
+ */
+export declare function validateExpectedBackendFederationIdentity(loaded: unknown, expected: BackendFederationExpectedIdentity, options?: {
+    /**
+     * Tolerate exposes that declare no identity metadata (legacy modules).
+     * Mismatching declared values still fail. Used by the manifest adapter,
+     * whose manifest-side identity is already validated against `expected`;
+     * the raw identity-aware loader is strict.
+     */
+    allowMissingIdentityMetadata?: boolean;
+}): BackendFederationIdentityIssue[];
+export declare function formatBackendFederationIdentityIssues(issues: BackendFederationIdentityIssue[]): string;

package/dist/types/backend-federation/index.d.ts

@@ -0,0 +1,6 @@
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from '@modern-js/utils/universal';
+export { type BackendFederationExpectedIdentity, type BackendFederationIdentityIssue, validateExpectedBackendFederationIdentity, } from './identity';
+export { createBackendFederationLoadEntryPlugin } from './plugin';
+export { createBackendFederationRuntime } from './runtime';
+export type { BackendFederatedEffectApiModule, BackendFederationEntryExports, BackendFederationIdentityLoadOptions, BackendFederationLoadEntryPluginOptions, BackendFederationRemote, BackendFederationRuntimeOptions, } from './types';
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, };

package/dist/types/backend-federation/legacy-warning.d.ts

@@ -0,0 +1 @@
+export declare 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.";