@bleedingdev/modern-js-plugin-bff-extensions 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/dist/esm-node/backend-federation/validate-loaded.mjs

@@ -8,10 +8,8 @@ function validateLoadedBackendFederatedEffectApi(loaded, options) {
     if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
     if ('string' == typeof backendContract.name && backendContract.name !== options.remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} metadata name mismatch: expected ${options.remoteName}, received ${backendContract.name}.`);
     if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must expose runtime.`);
-    if (void 0 !== options.expected) {
-        const issues = validateExpectedBackendFederationIdentity(loaded, options.expected, {
-            allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
-        });
+    {
+        const issues = validateExpectedBackendFederationIdentity(loaded, options.expected);
         if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} delivery-unit identity mismatch: ${formatBackendFederationIdentityIssues(issues)}.`);
     }
     return loaded;

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

@@ -2,6 +2,7 @@ import "node:module";
 import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "../backend-federation/index.mjs";
 import { loadBackendFederatedEffectApi } from "../backend-federation/load.mjs";
 import { BackendFederationManifestAdapterError } from "./errors.mjs";
+import { backendFederationMetadata, manifestDeliveryUnit, stringValue, versionBoundaryMetadata } from "./metadata.mjs";
 import { loadBackendFederationManifest } from "./reference.mjs";
 import { resolveBackendFederationRemoteFromManifest } from "./remote.mjs";
 import { classifyLoadError, validateBackendFederationManifest, validateLoadedBackendFederationContract } from "./validation.mjs";
@@ -96,6 +97,10 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
         if (remoteManifest && /^https?:\/\//iu.test(remote.entry) && !hasPinnedRemoteEntryExpectation(options)) throw new BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} from a network manifest requires caller-pinned entryUrl, remoteName, sha256, and byteLength values.`);
         if (/^https?:\/\//iu.test(remote.entry) && void 0 === remote.verification && options.entryPolicy?.expected === void 0) throw new BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} requires entry.sha256 and entry.byteLength before network execution.`);
         if (/^https?:\/\//iu.test(remote.entry) && void 0 !== options.runtime) throw new BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} cannot use a custom runtime for network entry execution.`);
+        const deliveryUnit = manifestDeliveryUnit(backendFederationMetadata(manifest), versionBoundaryMetadata(manifest));
+        const unitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
+        const buildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
+        if (!unitId || !buildMarker) throw new BackendFederationManifestAdapterError('manifest_invalid', 'Backend federation manifest requires delivery-unit identity.');
         const loaded = await loadBackendFederatedEffectApi({
             hostName: options.hostName,
             remote,
@@ -110,13 +115,10 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
             ...options.runtime ? {
                 runtime: options.runtime
             } : {},
-            ...options.expected?.unitId && options.expected.buildMarker ? {
-                expected: {
-                    unitId: options.expected.unitId,
-                    buildMarker: options.expected.buildMarker
-                },
-                allowMissingIdentityMetadata: true
-            } : {}
+            expected: {
+                unitId,
+                buildMarker
+            }
         }).catch((error)=>{
             throw new BackendFederationManifestAdapterError(scope?.timedOut() === true ? 'timeout' : classifyLoadError(error), `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE}.`, error);
         });

package/dist/esm-node/backend-federation-manifest/metadata.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { backendFederationMetadata, backendFederationVersionBoundary } from "@modern-js/utils/universal";
+import { backendFederationMetadata, backendFederationVersionBoundary } from "@modern-js/backend-federation-contracts";
 function stringValue(value) {
     return 'string' == typeof value && value.length > 0 ? value : void 0;
 }

package/dist/esm-node/backend-federation-manifest/remote.mjs

@@ -1,6 +1,6 @@
 import "node:module";
+import { backendFederationExposeNames } from "@modern-js/backend-federation-contracts";
 import { BackendFederationRemoteEntryError, resolveBackendFederationRemoteEntryVerification } from "@modern-js/server-runtime-extensions/backend-federation-security";
-import { backendFederationExposeNames } from "@modern-js/utils/universal";
 import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "../backend-federation/index.mjs";
 import { BackendFederationManifestAdapterError, assertManifestAdapter } from "./errors.mjs";
 import { backendFederationMetadata, recordField, resolveRemoteEntryFromMetadata, stringValue } from "./metadata.mjs";

package/dist/esm-node/backend-federation-manifest/validation.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { formatBackendFederationValidationErrors, validateBackendFederationManifest } from "@modern-js/utils/universal";
+import { formatBackendFederationValidationErrors, validateBackendFederationManifest } from "@modern-js/backend-federation-contracts";
 import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "../backend-federation/index.mjs";
 import { BackendFederationManifestAdapterError, assertConsistentValue, assertManifestAdapter, assertVersionValue } from "./errors.mjs";
 import { backendFederationMetadata, manifestDeliveryUnit, recordField, stringValue, versionBoundaryMetadata } from "./metadata.mjs";
@@ -17,8 +17,7 @@ function validation_validateBackendFederationManifest(manifest, expected = {}) {
     assertManifestAdapter(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
     const manifestShape = validateBackendFederationManifest(manifest, {
         expectedContractVersion: false,
-        expectedNodeAdapterVersion: false,
-        validateDeliveryUnit: false
+        expectedNodeAdapterVersion: false
     });
     assertManifestAdapter(manifestShape.ok, 'manifest_invalid', `[BFF][Effect] Backend federation manifest schema invalid: ${formatBackendFederationValidationErrors(manifestShape.errors)}.`);
     assertManifestAdapter('effect' === backendFederation.runtimeFramework, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare runtimeFramework: "effect".');
@@ -36,6 +35,7 @@ function validation_validateBackendFederationManifest(manifest, expected = {}) {
     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);
+    assertManifestAdapter(manifestUnitId && stringValue(deliveryUnit.boundary?.buildMarker), 'manifest_invalid', 'Backend federation manifest requires delivery-unit unitId and buildMarker.');
     assertVersionValue(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
     assertVersionValue(stringValue(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
 }
@@ -54,8 +54,8 @@ function validateLoadedBackendFederationContract(loaded, manifest, remote) {
     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');
+    assertVersionValue(stringValue(compatibility.unitId), manifestUnitId, 'deliveryUnit.unitId vs expose compatibility.unitId');
+    assertVersionValue(stringValue(compatibility.build), manifestBuildMarker, 'deliveryUnit.buildMarker vs expose compatibility.build');
 }
 function classifyLoadError(error) {
     const message = error instanceof Error ? error.message : String(error);

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

@@ -1,5 +1,5 @@
 import "node:module";
-import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/bff-core/security/cross-project-policy";
+import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/server-runtime-extensions/bff-policy";
 const DENIAL_HEADERS = {
     'content-type': 'application/json; charset=utf-8'
 };

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

@@ -1,7 +1,8 @@
 import "node:module";
 import { readFileSync } from "node:fs";
 import node_path from "node:path";
-import { deriveOperationVersion, resolveCrossProjectPolicy } from "@modern-js/bff-core";
+import "@modern-js/server-runtime-extensions/server-config";
+import { deriveOperationVersion, resolveCrossProjectPolicy } from "@modern-js/server-runtime-extensions/bff-policy/node";
 const readNearestPackageVersion = (startDir)=>{
     if (!startDir) return;
     let current = node_path.resolve(startDir);

package/dist/esm-node/cross-project-policy/producer-runtime.mjs

@@ -0,0 +1,21 @@
+import "node:module";
+function createProducerClient(configure, { requestId }) {
+    return (options)=>configure({
+            requestId,
+            requireEnvelope: true,
+            ...options,
+            identityBinding: {
+                enabled: true,
+                strict: true,
+                ...options?.identityBinding
+            },
+            operationContract: {
+                enabled: true,
+                strict: true,
+                requireSchemaHash: true,
+                requireOperationVersion: true,
+                ...options?.operationContract
+            }
+        });
+}
+export { createProducerClient };

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

@@ -1,5 +1,6 @@
 import "node:module";
 import node_path from "node:path";
+import "@modern-js/server-runtime-extensions/server-config";
 import { API_DIR, findExists, fs, isProd } from "@modern-js/utils";
 const JS_OR_TS_EXTS = [
     '.js',

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

@@ -1,5 +1,6 @@
 import "node:module";
 import node_path from "node:path";
+import "@modern-js/server-runtime-extensions/server-config";
 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";
@@ -137,4 +138,7 @@ class EffectAdapter {
         this.api = api;
     }
 }
-export { EffectAdapter };
+const createRuntimeAdapters = (api)=>[
+        new EffectAdapter(api)
+    ];
+export { EffectAdapter, createRuntimeAdapters };

package/dist/esm-node/{client-generator → effect-source-loader}/built-entry.mjs

@@ -18,7 +18,7 @@ async function bundleBuiltEffectEntryForNode(options) {
     });
     const builtEntry = resolveBuiltEffectEntry(appDir, distDir, sourceEntry);
     if (void 0 === builtEntry || 0 === builtEntry.length) throw new Error(`Effect BFF entry was not emitted into ${distDir}: ${sourceEntry ?? upath.resolve(apiDir, 'index')}`);
-    const { bundleEffectEntryForNode } = await import("../effect-source-loader/loader.mjs");
+    const { bundleEffectEntryForNode } = await import("./loader.mjs");
     return bundleEffectEntryForNode({
         appDir,
         entryPath: builtEntry,

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

@@ -0,0 +1,20 @@
+import "node:module";
+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-node/effect-source-loader/index.mjs

@@ -1,4 +1,7 @@
 import "node:module";
-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-node/effect-source-loader/loader.mjs

@@ -48,14 +48,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: {
-                        '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,
@@ -98,7 +102,6 @@ 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) {
@@ -138,28 +141,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,
@@ -187,7 +172,6 @@ async function bundleEffectEntryForNode(options) {
         platform: 'node',
         plugins: [
             externalizeInstalledDependencies({
-                format: options.format,
                 runtimeResolveDir: options.appDir
             }),
             preserveSourceModuleSemantics()
@@ -261,7 +245,6 @@ async function loadEffectSourceModule(options) {
         platform: 'node',
         plugins: [
             externalizeInstalledDependencies({
-                format: 'esm',
                 runtimeResolveDir: appDir
             }),
             preserveSourceModuleSemantics()

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

@@ -0,0 +1,46 @@
+import "node:module";
+import { collectEffectEndpoints, toOperationContractSources } from "@modern-js/bff-effect/effect";
+import { buildOperationContractMap, deriveOperationVersion } from "@modern-js/server-runtime-extensions/bff-policy/node";
+import { fs, upath } from "@modern-js/utils";
+import { getHttpApiRuntime, loadEffectApi } from "./http-api-runtime.mjs";
+function getPackageInfo(resourcePath, appDir, onDependency) {
+    for (const startDir of [
+        upath.dirname(resourcePath),
+        appDir
+    ]){
+        let current = upath.resolve(startDir);
+        for(let depth = 0; depth < 32; depth += 1){
+            const packageJsonPath = upath.join(current, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                onDependency?.(packageJsonPath);
+                try {
+                    const packageJson = fs.readJSONSync(packageJsonPath);
+                    return {
+                        name: packageJson.name,
+                        version: packageJson.version
+                    };
+                } catch  {
+                    return {};
+                }
+            }
+            const parent = upath.dirname(current);
+            if (parent === current) break;
+            current = parent;
+        }
+    }
+    return {};
+}
+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);
+    const packageInfo = getPackageInfo(options.resourcePath, options.appDir, options.onDependency);
+    const requestId = options.requestId?.trim() || packageInfo.name || 'default';
+    return buildOperationContractMap({
+        handlers: toOperationContractSources(endpoints),
+        requestId,
+        operationVersion: deriveOperationVersion(packageInfo.version)
+    });
+}
+export { resolveEffectOperationContracts };

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

@@ -0,0 +1,37 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+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-node/effect-source-loader/worker-runtime-source.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+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-node/effect-source-loader/worker-runtime-wrapper.mjs

@@ -1,57 +1,17 @@
 import "node:module";
+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-node/hono/cross-project-policy.mjs

@@ -6,6 +6,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/hono/node.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+import { logger } from "@modern-js/utils";
+import { resolveAdapterCrossProjectPolicy } from "../cross-project-policy/node.mjs";
+import { bindHonoRouteHandlers } from "./bind-route-handlers.mjs";
+const createHonoRouteBinder = (api, handlers)=>{
+    const policy = resolveAdapterCrossProjectPolicy(api, handlers);
+    return (options)=>bindHonoRouteHandlers({
+            ...options,
+            policy,
+            onError: api.getServerConfig()?.onError,
+            reportError: (error)=>logger.error(error)
+        });
+};
+export { createHonoRouteBinder };

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

@@ -1,5 +1,5 @@
-import type { BackendFederationExpectedIdentity } from './identity';
-import type { BackendFederationEntryExports } from './types';
+import type { BackendFederationExpectedIdentity } from './identity.js';
+import type { BackendFederationEntryExports } from './types.js';
 export type BackendFederationEdgeLoadEntryPlugin = {
     name: string;
     loadEntry: (args: {
@@ -33,14 +33,9 @@ type BackendFederationEdgeRuntimeBaseOptions = {
 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

@@ -1,9 +1,9 @@
-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';
+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 { type BackendFederationEdgeLoadEntryPlugin, type BackendFederationEdgeLoadEntryPluginOptions, type BackendFederationEdgeRemote, type BackendFederationEdgeRuntimeOptions } from './edge-runtime.js';
+import type { BackendFederatedEffectApiModule, BackendFederationLoadOptions, BackendFederationIdentityLoadOptions as UniversalBackendFederationIdentityLoadOptions } from './types.js';
+export { type BackendFederationEdgeLoadEntryPlugin, type BackendFederationEdgeLoadEntryPluginOptions, type BackendFederationEdgeRemote, type BackendFederationEdgeRuntime, type BackendFederationEdgeRuntimeOptions, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, } from './edge-runtime.js';
+export { type BackendFederationExpectedIdentity, type BackendFederationIdentityIssue, validateExpectedBackendFederationIdentity, } from './identity.js';
+export type { BackendFederatedEffectApiModule, BackendFederationEntryExports, } from './types.js';
 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;
@@ -24,5 +24,3 @@ export type EdgeBackendFederationIdentityLoadOptions = Omit<UniversalBackendFede
 };
 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

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

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

@@ -15,16 +15,7 @@ export type BackendFederationIdentityIssue = {
  * 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.
+ * Missing identity metadata is an error.
  */
-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 validateExpectedBackendFederationIdentity(loaded: unknown, expected: BackendFederationExpectedIdentity): BackendFederationIdentityIssue[];
 export declare function formatBackendFederationIdentityIssues(issues: BackendFederationIdentityIssue[]): string;

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

@@ -1,6 +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';
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from '@modern-js/backend-federation-contracts';
+export { type BackendFederationExpectedIdentity, type BackendFederationIdentityIssue, validateExpectedBackendFederationIdentity, } from './identity.js';
+export { createBackendFederationLoadEntryPlugin } from './plugin.js';
+export { createBackendFederationRuntime } from './runtime.js';
+export type { BackendFederatedEffectApiModule, BackendFederationEntryExports, BackendFederationIdentityLoadOptions, BackendFederationLoadEntryPluginOptions, BackendFederationRemote, BackendFederationRuntimeOptions, } from './types.js';
 export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, };

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

@@ -1,13 +1,7 @@
-import type { BackendFederatedEffectApiModule, BackendFederationIdentityLoadOptions, BackendFederationLoadOptions } from './types';
+import type { BackendFederatedEffectApiModule, BackendFederationIdentityLoadOptions } from './types.js';
 /**
  * Load a federated Effect API with mandatory delivery-unit identity
  * validation (MV-G23): the loaded expose's compatibility metadata must match
  * `expected.unitId` + `expected.buildMarker`.
  */
 export declare function loadBackendFederatedEffectApi(options: BackendFederationIdentityLoadOptions): Promise<BackendFederatedEffectApiModule>;
-/**
- * @deprecated Pass `expected` (delivery-unit `unitId` + `buildMarker`).
- * Loads without an expected identity cannot be validated against a resolved
- * delivery-unit record and emit a runtime warning.
- */
-export declare function loadBackendFederatedEffectApi(options: BackendFederationLoadOptions): Promise<BackendFederatedEffectApiModule>;

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

@@ -1,4 +1,2 @@
-import type { BackendFederatedEffectApiModule, BackendFederationIdentityLoadOptions, BackendFederationLoadOptions } from './types';
+import type { BackendFederatedEffectApiModule, BackendFederationIdentityLoadOptions } from './types.js';
 export declare function loadBackendFederatedEffectApi(options: BackendFederationIdentityLoadOptions): Promise<BackendFederatedEffectApiModule>;
-/** @deprecated Pass `expected` delivery-unit identity. */
-export declare function loadBackendFederatedEffectApi(options: BackendFederationLoadOptions): Promise<BackendFederatedEffectApiModule>;

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

@@ -1,3 +1,3 @@
 import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-import type { BackendFederationLoadEntryPluginOptions } from './types';
+import type { BackendFederationLoadEntryPluginOptions } from './types.js';
 export declare function createBackendFederationLoadEntryPlugin(options: BackendFederationLoadEntryPluginOptions): ModuleFederationRuntimePlugin;

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

@@ -1,2 +1,2 @@
-import type { BackendFederationRuntimeOptions } from './types';
-export declare function collectRemotes(options: BackendFederationRuntimeOptions): import("./types").BackendFederationRemote[];
+import type { BackendFederationRuntimeOptions } from './types.js';
+export declare function collectRemotes(options: BackendFederationRuntimeOptions): import("./types.js").BackendFederationRemote[];

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

@@ -1,3 +1,3 @@
 import { ModuleFederation } from '@module-federation/runtime';
-import type { BackendFederationRuntimeOptions } from './types';
+import type { BackendFederationRuntimeOptions } from './types.js';
 export declare function createBackendFederationRuntime(options: BackendFederationRuntimeOptions): ModuleFederation;