@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm/effect-source-loader/http-api-runtime.mjs

@@ -0,0 +1,19 @@
+import { extractHttpApiFromModule } from "@modern-js/bff-effect/effect";
+import { HttpApi } from "effect/unstable/httpapi";
+import { loadEffectSourceModule } from "./loader.mjs";
+function getHttpApiRuntime() {
+    return Promise.resolve({
+        isHttpApi: HttpApi.isHttpApi,
+        reflect: (api, handlers)=>{
+            if (!HttpApi.isHttpApi(api)) throw new TypeError('[BFF][Effect] Expected an HttpApi contract.');
+            HttpApi.reflect(api, {
+                onGroup: handlers.onGroup ?? (()=>{}),
+                onEndpoint: handlers.onEndpoint
+            });
+        }
+    });
+}
+function loadEffectApi(options) {
+    return getHttpApiRuntime().then((httpApiRuntime)=>loadEffectSourceModule(options).then((mod)=>extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi)));
+}
+export { getHttpApiRuntime, loadEffectApi };

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

@@ -1,3 +1,6 @@
-export { resolveEffectEntryFile } from "../client-generator/paths.mjs";
+export { bundleBuiltEffectEntryForNode, resolveEffectEntryPaths } from "./built-entry.mjs";
 export { bundleEffectEntryForNode } from "./loader.mjs";
-export { generateEffectClientCode, generateEffectWorkerRuntimeWrapper } from "./worker-runtime-wrapper.mjs";
+export { resolveEffectOperationContracts } from "./operation-contracts.mjs";
+export { resolveEffectEntryFile } from "./paths.mjs";
+export { bundleEffectWorkerRuntimeSource } from "./worker-runtime-source.mjs";
+export { generateEffectWorkerRuntimeWrapper } from "./worker-runtime-wrapper.mjs";

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

@@ -47,16 +47,18 @@ function preserveSourceModuleSemantics() {
         name: 'modern-js-effect-source-semantics',
         setup (buildApi) {
             buildApi.onLoad({
-                filter: /\.[cm]?[jt]sx?$/
+                filter: /\.[cm]?[jt]sx?$/,
+                namespace: 'file'
             }, async (args)=>{
                 const loader = sourceLoader(args);
                 if (!loader) return;
                 const source = await node_fs.promises.readFile(args.path, 'utf8');
+                const canonicalSourcePath = await node_fs.promises.realpath(args.path);
                 const compiled = await transform(source, {
                     define: {
-                        __dirname: JSON.stringify(node_path.dirname(args.path)),
-                        __filename: JSON.stringify(args.path),
-                        'import.meta.url': JSON.stringify(pathToFileURL(args.path).href)
+                        __dirname: JSON.stringify(node_path.dirname(canonicalSourcePath)),
+                        __filename: JSON.stringify(canonicalSourcePath),
+                        'import.meta.url': JSON.stringify(pathToFileURL(canonicalSourcePath).href)
                     },
                     jsx: 'automatic',
                     loader,
@@ -77,6 +79,7 @@ const nodeBuiltins = new Set([
     ...builtinModules.map((name)=>`node:${name}`)
 ]);
 const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+const BFF_RUNTIME_PACKAGE = /^@modern-js\/(?:bff-effect|plugin-bff)(?:\/|$)/;
 async function isEsmOnlyFile(filename) {
     const extension = node_path.extname(filename).toLowerCase();
     if ('.mjs' === extension || '.mts' === extension) return true;
@@ -99,13 +102,16 @@ 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 (BFF_RUNTIME_PACKAGE.test(args.path)) return {
+                    external: true,
+                    path: args.path
+                };
                 if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
                     external: true,
                     path: args.path
@@ -129,7 +135,8 @@ function externalizeInstalledDependencies(options) {
                     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 loader = SOURCE_LOADERS.get(node_path.extname(realPath).toLowerCase());
+                if (realPath.includes(`${node_path.sep}node_modules${node_path.sep}`) && 'ts' !== loader && 'tsx' !== loader && 'jsx' !== loader) {
                     const runtimeResolution = await buildApi.resolve(args.path, {
                         importer: '',
                         kind: args.kind,
@@ -139,28 +146,10 @@ function externalizeInstalledDependencies(options) {
                         },
                         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
-                        };
-                    }
+                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) return {
+                        external: true,
+                        path: args.path
+                    };
                 }
                 return {
                     namespace: resolution.namespace,
@@ -188,7 +177,6 @@ async function bundleEffectEntryForNode(options) {
         platform: 'node',
         plugins: [
             externalizeInstalledDependencies({
-                format: options.format,
                 runtimeResolveDir: options.appDir
             }),
             preserveSourceModuleSemantics()
@@ -262,7 +250,6 @@ async function loadEffectSourceModule(options) {
         platform: 'node',
         plugins: [
             externalizeInstalledDependencies({
-                format: 'esm',
                 runtimeResolveDir: appDir
             }),
             preserveSourceModuleSemantics()

package/dist/esm/effect-source-loader/operation-contracts.mjs

@@ -0,0 +1,22 @@
+import { collectEffectEndpoints, toOperationContractSources } from "@modern-js/bff-effect/effect";
+import { buildOperationContractMap, resolveOperationProducer } from "@modern-js/server-runtime-extensions/bff-policy/node";
+import { upath } from "@modern-js/utils";
+import { getHttpApiRuntime, loadEffectApi } from "./http-api-runtime.mjs";
+async function resolveEffectOperationContracts(options) {
+    const api = await loadEffectApi(options);
+    if (null === api) return null;
+    const runtime = await getHttpApiRuntime();
+    const endpoints = collectEffectEndpoints(runtime.reflect, api, options.prefix);
+    return buildOperationContractMap({
+        handlers: toOperationContractSources(endpoints),
+        ...resolveOperationProducer({
+            directories: [
+                upath.dirname(options.resourcePath),
+                options.appDir
+            ],
+            requestId: options.requestId,
+            onDependency: options.onDependency
+        })
+    });
+}
+export { resolveEffectOperationContracts };

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

@@ -0,0 +1,43 @@
+import { findExists, fs, upath } from "@modern-js/utils";
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+const emittedEffectEntry = (entry)=>entry.replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
+function relativeEffectAppPath(appDir, entry) {
+    const relative = upath.relative(appDir, entry);
+    return '..' === relative || relative.startsWith('../') || relative.split('/').includes('node_modules') ? void 0 : relative;
+}
+function existingEntry(entry) {
+    return upath.extname(entry) ? fs.existsSync(entry) ? entry : void 0 : findExists(JS_OR_TS_EXTS.map((ext)=>`${entry}${ext}`)) || void 0;
+}
+function resolveEffectEntry(options) {
+    const { appDir, apiDir, effectEntry, distDir } = options;
+    const entry = upath.resolve(appDir, effectEntry || upath.join(apiDir, 'index'));
+    if (distDir && void 0 !== relativeEffectAppPath(distDir, entry)) return {
+        kind: 'built-output',
+        path: existingEntry(emittedEffectEntry(entry))
+    };
+    const relative = relativeEffectAppPath(appDir, entry);
+    if (void 0 === relative) return {
+        kind: 'external-sdk',
+        path: existingEntry(entry)
+    };
+    return distDir ? {
+        kind: 'built-output',
+        path: existingEntry(emittedEffectEntry(upath.resolve(distDir, relative)))
+    } : {
+        kind: 'app-source',
+        path: existingEntry(entry)
+    };
+}
+function resolveEffectEntryFile(options) {
+    return resolveEffectEntry(options).path;
+}
+export { emittedEffectEntry, relativeEffectAppPath, resolveEffectEntry, resolveEffectEntryFile };

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

@@ -0,0 +1,35 @@
+import { realpathSync } from "node:fs";
+import { bundleEffectWorkerRuntimeSource, generateEffectWorkerRuntimeWrapper, resolveEffectEntryFile } from "./index.mjs";
+async function loader(source) {
+    this.cacheable();
+    delete require.cache[this.resourcePath];
+    const callback = this.async();
+    try {
+        const options = this.getOptions();
+        const entry = resolveEffectEntryFile(options);
+        if (!entry || realpathSync(entry) !== realpathSync(this.resourcePath)) throw new Error(`Unexpected Effect BFF loader resource: ${this.resourcePath}`);
+        const query = new URLSearchParams(this.resourceQuery);
+        if (query.has('modern-bff-runtime-source')) {
+            const { transform } = await import("@swc/core");
+            const transformed = await transform(source, {
+                filename: this.resourcePath,
+                sourceMaps: false,
+                jsc: {
+                    parser: {
+                        syntax: "typescript",
+                        tsx: /\.[jt]sx$/.test(this.resourcePath)
+                    },
+                    target: 'es2024'
+                },
+                module: {
+                    type: 'es6'
+                }
+            });
+            callback(void 0, await bundleEffectWorkerRuntimeSource(transformed.code, this.resourcePath, this));
+        } else if (query.has('modern-bff-runtime')) callback(void 0, await generateEffectWorkerRuntimeWrapper(this, options, this.resourcePath));
+        else throw new Error('Effect BFF entries are server-only. Import the shared HttpApi contract and use HttpApiClient.make (or makeEffectHttpApiClient) for a fully inferred client.');
+    } catch (error) {
+        callback(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export default loader;

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

@@ -0,0 +1,23 @@
+import node_path from "node:path";
+import { build } from "esbuild";
+async function bundleEffectWorkerRuntimeSource(source, resourcePath, loader) {
+    const result = await build({
+        absWorkingDir: node_path.dirname(resourcePath),
+        bundle: true,
+        format: 'esm',
+        metafile: true,
+        packages: 'external',
+        platform: 'neutral',
+        stdin: {
+            contents: source,
+            loader: 'js',
+            resolveDir: node_path.dirname(resourcePath),
+            sourcefile: resourcePath
+        },
+        target: 'es2024',
+        write: false
+    });
+    for (const dependency of Object.keys(result.metafile.inputs))if ('<stdin>' !== dependency) loader.addDependency(node_path.resolve(node_path.dirname(resourcePath), dependency));
+    return result.outputFiles[0].text;
+}
+export { bundleEffectWorkerRuntimeSource };

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

@@ -1,56 +1,16 @@
+import { resolveEffectOperationContracts } from "./operation-contracts.mjs";
 async function generateEffectWorkerRuntimeWrapper(loader, options, resourcePath) {
-    const { generateEffectClient } = await import("../client-generator/generator.mjs");
-    const artifacts = await generateEffectClient({
+    const operationContracts = await resolveEffectOperationContracts({
         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,
-  });
+import { createEffectBffEdgeDispatcherFactory } from '@modern-js/bff-effect/effect-edge';
+export const __modern_create_effect_bff_dispatcher = createEffectBffEdgeDispatcherFactory(effectBffModule, ${JSON.stringify(operationContracts ?? {})});
 `;
 }
-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 };
+export { generateEffectWorkerRuntimeWrapper };

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

@@ -5,6 +5,7 @@ const createHonoCrossProjectPolicyMiddleware = (policy, routePath)=>async functi
             routePath
         });
         if (denial) return denial;
-        return next();
+        const result = await next();
+        return result instanceof Response ? result : void 0;
     };
 export { createHonoCrossProjectPolicyMiddleware };

package/dist/esm-node/backend-federation/edge-runtime.mjs

@@ -67,7 +67,7 @@ async function resolveEdgeEntry(plugins, remote) {
     }
     throw new Error(`[BFF][Effect] Missing static or service-binding entry provider for backend federation remote ${remote.name}.`);
 }
-var _entries = /*#__PURE__*/ new WeakMap(), _expected = /*#__PURE__*/ new WeakMap(), _hostName = /*#__PURE__*/ new WeakMap(), _allowMissingIdentityMetadata = /*#__PURE__*/ new WeakMap(), _modules = /*#__PURE__*/ new WeakMap(), _plugins = /*#__PURE__*/ new WeakMap(), _remotes = /*#__PURE__*/ new WeakMap(), _loadEntry = /*#__PURE__*/ new WeakSet(), _loadModule = /*#__PURE__*/ new WeakSet();
+var _entries = /*#__PURE__*/ new WeakMap(), _expected = /*#__PURE__*/ new WeakMap(), _hostName = /*#__PURE__*/ new WeakMap(), _modules = /*#__PURE__*/ new WeakMap(), _plugins = /*#__PURE__*/ new WeakMap(), _remotes = /*#__PURE__*/ new WeakMap(), _loadEntry = /*#__PURE__*/ new WeakSet(), _loadModule = /*#__PURE__*/ new WeakSet();
 class EdgeBackendFederationRuntime {
     async loadRemote(request) {
         const existing = _class_private_field_get(this, _modules).get(request);
@@ -94,10 +94,6 @@ class EdgeBackendFederationRuntime {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _allowMissingIdentityMetadata, {
-            writable: true,
-            value: void 0
-        });
         _class_private_field_init(this, _modules, {
             writable: true,
             value: void 0
@@ -113,7 +109,6 @@ class EdgeBackendFederationRuntime {
         _class_private_field_set(this, _entries, new Map());
         _class_private_field_set(this, _modules, new Map());
         if (void 0 !== options.entryPolicy) throw new Error('[BFF][Effect] Edge backend federation does not execute entry evaluators. Register a static or service-binding entry provider.');
-        _class_private_field_set(this, _allowMissingIdentityMetadata, true === options.allowMissingIdentityMetadata);
         _class_private_field_set(this, _expected, options.expected);
         _class_private_field_set(this, _hostName, options.hostName);
         _class_private_field_set(this, _plugins, options.plugins ?? []);
@@ -152,7 +147,6 @@ function loadModule(request) {
         if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${expose.replace(/^\.\//u, '')} must load factory function.`);
         const loaded = await factory();
         return validateLoadedBackendFederatedEffectApi(loaded, {
-            allowMissingIdentityMetadata: _class_private_field_get(this, _allowMissingIdentityMetadata),
             expected: _class_private_field_get(this, _expected),
             remoteName,
             remoteRequest: request
@@ -181,7 +175,4 @@ function createBackendFederationRuntime(options) {
     if (void 0 === options.expected || 'string' != typeof options.expected.unitId || 0 === options.expected.unitId.length || 'string' != typeof options.expected.buildMarker || 0 === options.expected.buildMarker.length) throw new Error('[BFF][Effect] Edge backend federation runtime requires expected.unitId and expected.buildMarker.');
     return new EdgeBackendFederationRuntime(options);
 }
-function createBackendFederationRuntimeForLoad(options) {
-    return new EdgeBackendFederationRuntime(options);
-}
-export { createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, createBackendFederationRuntimeForLoad };
+export { createBackendFederationLoadEntryPlugin, createBackendFederationRuntime };

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

@@ -1,18 +1,17 @@
 import "node:module";
-import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "@modern-js/utils/universal";
-import { createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, createBackendFederationRuntimeForLoad } from "./edge-runtime.mjs";
-import { LEGACY_LOAD_WARNING } from "./legacy-warning.mjs";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "@modern-js/backend-federation-contracts";
+import { createBackendFederationLoadEntryPlugin, createBackendFederationRuntime } from "./edge-runtime.mjs";
 import { normalizeExpose } from "./utils.mjs";
 function loadBackendFederatedEffectApi(options) {
-    if (void 0 !== options.runtime || void 0 !== options.entryPolicy) return Promise.reject(new Error('[BFF][Effect] Edge backend federation does not execute custom runtimes or entry evaluators. Register a static or service-binding entry provider.'));
+    if (void 0 !== options.runtime || void 0 !== options.entryPolicy || void 0 !== options.shared) return Promise.reject(new Error('[BFF][Effect] Edge backend federation does not execute custom runtimes, entry evaluators or host shares. Register a static or service-binding entry provider.'));
     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) console.warn(LEGACY_LOAD_WARNING);
+    if (!options.expected?.unitId || !options.expected.buildMarker) return Promise.reject(new Error('[BFF][Effect] Backend federation requires expected.unitId and expected.buildMarker.'));
     const expose = options.expose ?? options.remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE;
     const remoteRequest = `${remoteName}/${normalizeExpose(expose)}`;
     let runtime;
     try {
-        runtime = createBackendFederationRuntimeForLoad(options);
+        runtime = createBackendFederationRuntime(options);
     } catch (error) {
         return Promise.reject(error);
     }

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

@@ -1,42 +1,31 @@
 import "node:module";
 import { isRecord } from "./utils.mjs";
-function validateExpectedBackendFederationIdentity(loaded, expected, options = {}) {
-    const allowMissing = true === options.allowMissingIdentityMetadata;
-    const issues = [];
+function backendFederationCompatibility(loaded) {
     const contract = isRecord(loaded) ? loaded.backendFederationContract : void 0;
     const compatibility = isRecord(contract) ? contract.compatibility : void 0;
-    if (!isRecord(compatibility)) {
-        if (allowMissing) return [];
-        return [
+    return isRecord(compatibility) ? compatibility : void 0;
+}
+function validateBackendFederationCompatibility(compatibility, expected) {
+    return Object.entries(expected).flatMap(([field, value])=>void 0 === value || 'string' == typeof compatibility[field] && compatibility[field].length > 0 && compatibility[field] === value ? [] : [
             {
-                path: 'backendFederationContract.compatibility',
-                message: 'loaded module declares no compatibility metadata; delivery-unit identity cannot be validated'
+                path: `backendFederationContract.compatibility.${field}`,
+                message: `expected ${value}, received ${'string' == typeof compatibility[field] ? compatibility[field] : typeof compatibility[field]}`
             }
-        ];
-    }
-    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 validateExpectedBackendFederationIdentity(loaded, expected) {
+    const compatibility = backendFederationCompatibility(loaded);
+    return compatibility ? validateBackendFederationCompatibility(compatibility, {
+        unitId: expected.unitId,
+        build: expected.buildMarker
+    }) : [
+        {
+            path: 'backendFederationContract.compatibility',
+            message: 'loaded module declares no compatibility metadata; delivery-unit identity cannot be validated'
+        }
+    ];
 }
 function formatBackendFederationIdentityIssues(issues) {
     return issues.map((issue)=>`${issue.path}: ${issue.message}`).join('; ');
 }
-export { formatBackendFederationIdentityIssues, validateExpectedBackendFederationIdentity };
+export { backendFederationCompatibility, formatBackendFederationIdentityIssues, validateBackendFederationCompatibility, validateExpectedBackendFederationIdentity };

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

@@ -1,5 +1,5 @@
 import "node:module";
-export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "@modern-js/utils/universal";
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "@modern-js/backend-federation-contracts";
 export { validateExpectedBackendFederationIdentity } from "./identity.mjs";
 export { createBackendFederationLoadEntryPlugin } from "./plugin.mjs";
 export { createBackendFederationRuntime } from "./runtime.mjs";

package/dist/esm-node/backend-federation/integrity-plugin.mjs

@@ -0,0 +1,69 @@
+import "node:module";
+import { evaluateBackendFederationCommonJsEntry, loadVerifiedBackendFederationEntry } from "@modern-js/server-runtime-extensions/backend-federation-security";
+import { Module } from "@module-federation/runtime";
+const PROVIDED_ENTRY_SCHEME = /^(?:binding|service|static):/u;
+function decodeDataUrl(remote) {
+    const commaIndex = remote.entry.indexOf(',');
+    if (commaIndex < 0) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} has an invalid data URL entry.`);
+    return new TextEncoder().encode(decodeURIComponent(remote.entry.slice(commaIndex + 1)));
+}
+async function importContainer(remote) {
+    const namespace = await import(remote.entry);
+    return namespace.default ?? namespace;
+}
+function loadContainer(remote, options) {
+    const verified = Boolean(remote.verification || options.entryPolicy?.expected);
+    const scheme = /^[a-z][a-z0-9+.-]*:/iu.exec(remote.entry)?.[0].toLowerCase();
+    if ('https:' === scheme || 'http:' === scheme) {
+        if (!verified) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} requires verified entry bytes before network execution.`);
+        return loadVerifiedBackendFederationEntry({
+            ...options.entryPolicy,
+            remote,
+            ...remote.verification ? {
+                verification: remote.verification
+            } : {}
+        });
+    }
+    if (verified) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} declares entry verification, but only http(s) entries are fetched and verified.`);
+    if ('data:' === scheme && 'module' !== remote.type) return Promise.resolve(evaluateBackendFederationCommonJsEntry(remote, decodeDataUrl(remote), options.entryPolicy?.evaluateCommonJs));
+    if ('data:' === scheme || 'file:' === scheme) return importContainer(remote);
+    throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} uses unsupported entry ${remote.entry}. Use a verified http(s) entry, a data: or file: entry, or a binding:, service: or static: entry served by createBackendFederationLoadEntryPlugin().`);
+}
+function registerRemoteContainer(origin, remoteInfo, container) {
+    const module = new Module({
+        host: origin,
+        remoteInfo
+    });
+    module.remoteEntryExports = container;
+    origin.moduleCache.set(remoteInfo.name, module);
+}
+function createBackendFederationIntegrityPlugin(options, remotes) {
+    const loading = new Map();
+    const register = async (origin, remoteInfo)=>{
+        const remote = remotes.find((candidate)=>candidate.name === remoteInfo.name);
+        if (void 0 === remote) throw new Error(`[BFF][Effect] Missing backend federation remote ${remoteInfo.name}.`);
+        if (PROVIDED_ENTRY_SCHEME.test(remote.entry)) {
+            if (origin.moduleCache.get(remote.name)?.remoteEntryExports === void 0) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} has no entry provider for ${remote.entry}. Pass createBackendFederationLoadEntryPlugin() in plugins.`);
+            return;
+        }
+        const container = await loadContainer(remote, options);
+        if ('function' != typeof container?.get) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`);
+        registerRemoteContainer(origin, remoteInfo, container);
+    };
+    return {
+        name: 'modernjs-backend-federation-integrity',
+        afterMatchRemote ({ origin, remoteInfo }) {
+            if (void 0 === remoteInfo) return;
+            let pending = loading.get(remoteInfo.name);
+            if (void 0 === pending) {
+                pending = register(origin, remoteInfo);
+                loading.set(remoteInfo.name, pending);
+                pending.catch(()=>{
+                    if (loading.get(remoteInfo.name) === pending) loading.delete(remoteInfo.name);
+                });
+            }
+            return pending;
+        }
+    };
+}
+export { PROVIDED_ENTRY_SCHEME, createBackendFederationIntegrityPlugin, registerRemoteContainer };

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

@@ -1,22 +1,13 @@
 import "node:module";
-import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "@modern-js/utils/universal";
-import { LEGACY_LOAD_WARNING } from "./legacy-warning.mjs";
+import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "@modern-js/backend-federation-contracts";
 import { collectRemotes } from "./remotes.mjs";
 import { createBackendFederationRuntime } from "./runtime.mjs";
 import { normalizeExpose } from "./utils.mjs";
 import { validateLoadedBackendFederatedEffectApi } from "./validate-loaded.mjs";
-import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
-import * as __rspack_external_effect_Logger_1691a01b from "effect/Logger";
-const legacyWarningLogger = __rspack_external_effect_Logger_1691a01b.withLeveledConsole(__rspack_external_effect_Logger_1691a01b.formatLogFmt);
-function warnLegacyLoad() {
-    __rspack_external_effect_Effect_41060786.runSync(__rspack_external_effect_Effect_41060786.provideService(__rspack_external_effect_Effect_41060786.logWarning(LEGACY_LOAD_WARNING), __rspack_external_effect_Logger_1691a01b.CurrentLoggers, new Set([
-        legacyWarningLogger
-    ])));
-}
 function loadBackendFederatedEffectApi(options) {
     const remoteName = options.remote?.name ?? options.remoteName;
     if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
-    if (void 0 === options.expected) warnLegacyLoad();
+    if (!options.expected?.unitId || !options.expected.buildMarker) return Promise.reject(new Error('[BFF][Effect] Backend federation requires expected.unitId and expected.buildMarker.'));
     if (void 0 !== options.runtime) {
         const configuredRemote = collectRemotes(options).find((remote)=>remote.name === remoteName);
         if (void 0 === configuredRemote || !/^(?:binding|service|static):/u.test(configuredRemote.entry)) return Promise.reject(new Error('[BFF][Effect] A custom Module Federation runtime requires a caller-pinned static or service-binding remote and cannot execute network backend federation entries.'));
@@ -26,7 +17,6 @@ function loadBackendFederatedEffectApi(options) {
     const expose = options.expose ?? options.remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE;
     const remoteRequest = `${remoteName}/${normalizeExpose(expose)}`;
     return runtime.loadRemote(remoteRequest).then((loaded)=>validateLoadedBackendFederatedEffectApi(loaded, {
-            allowMissingIdentityMetadata: options.allowMissingIdentityMetadata,
             expected: options.expected,
             remoteName,
             remoteRequest

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

@@ -0,0 +1,42 @@
+import "node:module";
+import { createRequire } from "node:module";
+const fromAdapter = createRequire(import.meta.url);
+const effectPackageJson = fromAdapter.resolve('@modern-js/bff-effect/package.json');
+const fromEffectPackage = createRequire(effectPackageJson);
+let hostShared;
+function effectBffHostShared() {
+    if (void 0 !== hostShared) return hostShared;
+    const { EFFECT_BFF_CONTEXT_STORAGE_SHARE, EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE } = fromEffectPackage('@modern-js/bff-effect/effect-edge');
+    const { getEffectContextStorage } = fromEffectPackage('@modern-js/bff-effect/context');
+    const handlerFactoryRegistry = fromEffectPackage("#effect-entry-shape-registry");
+    const version = fromAdapter(effectPackageJson).version;
+    hostShared = {
+        [EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE]: {
+            version,
+            lib: ()=>handlerFactoryRegistry,
+            shareConfig: {
+                singleton: true,
+                requiredVersion: false
+            }
+        },
+        [EFFECT_BFF_CONTEXT_STORAGE_SHARE]: {
+            version,
+            lib: getEffectContextStorage,
+            shareConfig: {
+                singleton: true,
+                requiredVersion: false
+            }
+        }
+    };
+    return hostShared;
+}
+function withEffectBffHostShared(shared) {
+    const host = effectBffHostShared();
+    const reserved = Object.keys(host).find((name)=>shared && name in shared);
+    if (void 0 !== reserved) throw new Error(`[BFF][Effect] Share ${reserved} is reserved for the Node host. Remove it from options.shared.`);
+    return {
+        ...shared,
+        ...host
+    };
+}
+export { effectBffHostShared, withEffectBffHostShared };