@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

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

@@ -1,36 +1,31 @@
 import "node:module";
 import { isRecord } from "./utils.mjs";
-function validateExpectedBackendFederationIdentity(loaded, expected) {
-    const issues = [];
+function backendFederationCompatibility(loaded) {
     const contract = isRecord(loaded) ? loaded.backendFederationContract : void 0;
     const compatibility = isRecord(contract) ? contract.compatibility : void 0;
-    if (!isRecord(compatibility)) 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.${field}`,
+                message: `expected ${value}, received ${'string' == typeof compatibility[field] ? compatibility[field] : typeof compatibility[field]}`
+            }
+        ]);
+}
+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'
         }
     ];
-    const unitId = compatibility.unitId;
-    if ('string' != typeof unitId || 0 === unitId.length) 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) issues.push({
-        path: 'backendFederationContract.compatibility.build',
-        message: `missing build marker; expected ${expected.buildMarker}`
-    });
-    else if (build !== expected.buildMarker) issues.push({
-        path: 'backendFederationContract.compatibility.build',
-        message: `expected ${expected.buildMarker}, received ${build}`
-    });
-    return issues;
 }
 function formatBackendFederationIdentityIssues(issues) {
     return issues.map((issue)=>`${issue.path}: ${issue.message}`).join('; ');
 }
-export { formatBackendFederationIdentityIssues, validateExpectedBackendFederationIdentity };
+export { backendFederationCompatibility, formatBackendFederationIdentityIssues, validateBackendFederationCompatibility, validateExpectedBackendFederationIdentity };

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

@@ -0,0 +1,8 @@
+import "node:module";
+import { createRequire } from "node:module";
+import { evaluateNodeBackendFederationCommonJs } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
+const fromAdapter = createRequire(import.meta.url);
+const fromEffectPackage = createRequire(fromAdapter.resolve('@modern-js/bff-effect/package.json'));
+const privateRegistry = fromEffectPackage("#effect-entry-shape-registry");
+const evaluateEffectBackendFederationCommonJs = (source, context)=>evaluateNodeBackendFederationCommonJs(source, context, privateRegistry);
+export { evaluateEffectBackendFederationCommonJs };

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

@@ -1,12 +1,12 @@
 import "node:module";
-import { evaluateNodeBackendFederationCommonJs } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
 import { loadBackendFederatedEffectApi } from "./load.mjs";
+import { evaluateEffectBackendFederationCommonJs } from "./node-evaluator.mjs";
 function node_loadBackendFederatedEffectApi(options) {
     return loadBackendFederatedEffectApi({
         ...options,
         entryPolicy: {
             ...options.entryPolicy,
-            evaluateCommonJs: options.entryPolicy?.evaluateCommonJs ?? evaluateNodeBackendFederationCommonJs
+            evaluateCommonJs: options.entryPolicy?.evaluateCommonJs ?? evaluateEffectBackendFederationCommonJs
         }
     });
 }

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

@@ -1,12 +1,12 @@
 import "node:module";
-import { evaluateNodeBackendFederationCommonJs } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
+import { evaluateEffectBackendFederationCommonJs } from "../backend-federation/node-evaluator.mjs";
 import { loadBackendFederatedEffectApiFromManifest } from "./load.mjs";
 function node_loadBackendFederatedEffectApiFromManifest(options) {
     return loadBackendFederatedEffectApiFromManifest({
         ...options,
         entryPolicy: {
             ...options.entryPolicy,
-            evaluateCommonJs: options.entryPolicy?.evaluateCommonJs ?? evaluateNodeBackendFederationCommonJs
+            evaluateCommonJs: options.entryPolicy?.evaluateCommonJs ?? evaluateEffectBackendFederationCommonJs
         }
     });
 }

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

@@ -1,8 +1,9 @@
 import "node:module";
 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 { backendFederationCompatibility, formatBackendFederationIdentityIssues, validateBackendFederationCompatibility } from "../backend-federation/identity.mjs";
 import { BackendFederationManifestAdapterError, assertConsistentValue, assertManifestAdapter, assertVersionValue } from "./errors.mjs";
-import { backendFederationMetadata, manifestDeliveryUnit, recordField, stringValue, versionBoundaryMetadata } from "./metadata.mjs";
+import { backendFederationMetadata, manifestDeliveryUnit, stringValue, versionBoundaryMetadata } from "./metadata.mjs";
 function resolveExpectedBuildMarker(expected) {
     if (void 0 !== expected.buildVersion && void 0 !== expected.buildMarker && expected.buildVersion !== expected.buildMarker) throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation expected buildVersion/buildMarker mismatch: buildVersion ${expected.buildVersion}, buildMarker ${expected.buildMarker}.`, void 0, {
         label: 'expected.buildVersion/buildMarker',
@@ -43,19 +44,22 @@ function validateLoadedBackendFederationContract(loaded, manifest, remote) {
     const loadedContract = loaded.backendFederationContract;
     const backendFederation = backendFederationMetadata(manifest);
     const boundary = versionBoundaryMetadata(manifest);
-    const compatibility = recordField(loadedContract, 'compatibility');
+    const compatibility = backendFederationCompatibility(loaded);
     assertManifestAdapter(compatibility, 'version_mismatch', `[BFF][Effect] Backend federation expose ${remote.name}/${remote.expose?.replace(/^\.\//u, '')} must declare compatibility metadata.`);
     assertVersionValue(stringValue(loadedContract?.role), 'microvertical-server', 'expose role');
     assertVersionValue(stringValue(loadedContract?.name), remote.name, 'expose name');
-    assertVersionValue(stringValue(compatibility.contractVersion), stringValue(backendFederation?.contractVersion), 'expose contractVersion');
-    assertVersionValue(stringValue(compatibility.nodeAdapterVersion), stringValue(backendFederation?.nodeAdapterVersion), 'expose nodeAdapterVersion');
-    assertVersionValue(stringValue(compatibility.packageName), stringValue(boundary?.packageName), 'expose packageName');
-    assertVersionValue(stringValue(compatibility.build), stringValue(boundary?.buildVersion), 'expose buildVersion');
     const deliveryUnit = manifestDeliveryUnit(backendFederation, boundary);
     const manifestUnitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
     const manifestBuildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
-    assertVersionValue(stringValue(compatibility.unitId), manifestUnitId, 'deliveryUnit.unitId vs expose compatibility.unitId');
-    assertVersionValue(stringValue(compatibility.build), manifestBuildMarker, 'deliveryUnit.buildMarker vs expose compatibility.build');
+    const issues = validateBackendFederationCompatibility(compatibility, {
+        contractVersion: stringValue(backendFederation?.contractVersion),
+        nodeAdapterVersion: stringValue(backendFederation?.nodeAdapterVersion),
+        packageName: stringValue(boundary?.packageName),
+        unitId: manifestUnitId,
+        build: manifestBuildMarker ?? stringValue(boundary?.buildVersion)
+    });
+    assertVersionValue(stringValue(compatibility.build), stringValue(boundary?.buildVersion), 'expose buildVersion');
+    assertManifestAdapter(0 === issues.length, 'version_mismatch', `[BFF][Effect] ${formatBackendFederationIdentityIssues(issues)}.`);
 }
 function classifyLoadError(error) {
     const message = error instanceof Error ? error.message : String(error);

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

@@ -1,30 +1,20 @@
 import "node:module";
-import { readFileSync } from "node:fs";
-import node_path from "node:path";
 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);
-    for(let depth = 0; depth < 10; depth += 1){
-        try {
-            const packageJson = JSON.parse(readFileSync(node_path.join(current, 'package.json'), 'utf8'));
-            if ('string' == typeof packageJson.version) return packageJson.version;
-        } catch  {}
-        const parent = node_path.dirname(current);
-        if (parent === current) break;
-        current = parent;
-    }
-};
-const resolveAdapterCrossProjectPolicy = (api, handlers)=>{
+import { resolveCrossProjectPolicy, resolveOperationProducer } from "@modern-js/server-runtime-extensions/bff-policy/node";
+const resolveAdapterCrossProjectPolicy = (api, handlers, producer)=>{
     const bff = api.getServerConfig()?.bff;
     const { apiDirectory, appDirectory } = api.getServerContext();
     return resolveCrossProjectPolicy({
         crossProjectPolicy: bff?.crossProjectPolicy,
         handlers,
-        requestId: bff?.requestId,
         isCrossProjectServer: bff?.isCrossProjectServer,
-        operationVersion: deriveOperationVersion(readNearestPackageVersion(apiDirectory) ?? readNearestPackageVersion(appDirectory))
+        ...producer ?? resolveOperationProducer({
+            directories: [
+                apiDirectory,
+                appDirectory
+            ],
+            requestId: bff?.requestId || 'default'
+        })
     });
 };
 export { resolveAdapterCrossProjectPolicy };

package/dist/esm-node/{effect-adapter → effect-server}/cross-project-policy.mjs

@@ -3,7 +3,7 @@ import { collectEffectEndpoints, extractHttpApiFromModule, toOperationContractSo
 import { logger } from "@modern-js/utils";
 import { HttpApi } from "effect/unstable/httpapi";
 import { resolveAdapterCrossProjectPolicy } from "../cross-project-policy/index.mjs";
-function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
+function resolveEffectServerCrossProjectPolicy(api, prefix, mod, producer) {
     const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>extractHttpApiFromModule(mod, HttpApi.isHttpApi)).then((effectApi)=>{
         if (null === effectApi) return [];
         const reflect = (apiValue, handlers)=>{
@@ -19,9 +19,9 @@ function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
         return [];
     });
     return contractSourcesPromise.then((contractSources)=>{
-        const policy = resolveAdapterCrossProjectPolicy(api, contractSources);
+        const policy = resolveAdapterCrossProjectPolicy(api, contractSources, producer);
         if (policy?.enabled === true && 0 === contractSources.length) logger.warn('[BFF][Effect] Cross-project policy enabled but no HttpApi endpoints could be reflected; requests fail operation-contract matching unless allowUnknownOperations is enabled.');
         return policy;
     });
 }
-export { resolveEffectAdapterCrossProjectPolicy };
+export { resolveEffectServerCrossProjectPolicy };

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

@@ -0,0 +1,16 @@
+import "node:module";
+import node_path from "node:path";
+import "@modern-js/server-runtime-extensions/server-config";
+import { API_DIR, isProd } from "@modern-js/utils";
+import { resolveEffectEntry } from "../effect-source-loader/paths.mjs";
+function resolveEffectServerEntryFile(api) {
+    const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
+    const appDir = node_path.resolve(appDirectory || process.cwd());
+    return resolveEffectEntry({
+        appDir,
+        apiDir: node_path.resolve(appDir, apiDirectory || API_DIR),
+        effectEntry: api.getServerConfig()?.bff?.effect?.entry,
+        distDir: isProd() && distDirectory ? node_path.resolve(distDirectory) : void 0
+    }).path;
+}
+export { resolveEffectServerEntryFile };

package/dist/esm-node/{effect-adapter → effect-server}/error-response.mjs

@@ -1,7 +1,7 @@
 import "node:module";
 import { createSafeFailureResponse } from "@modern-js/runtime-extensions/safe-failure";
 import { logger } from "@modern-js/utils";
-function createEffectAdapterRuntimeErrorResponse(api, error, context) {
+function createEffectServerRuntimeErrorResponse(api, error, context) {
     try {
         const onError = api.getServerConfig()?.onError;
         if (void 0 !== onError) return Promise.resolve(onError(error instanceof Error ? error : new Error(String(error)), ensureJsonContext(context))).then((result)=>result instanceof Response ? result : createSafeFailureResponse(error)).catch((configError)=>{
@@ -35,4 +35,4 @@ function ensureJsonContext(context) {
         }
     });
 }
-export { createEffectAdapterRuntimeErrorResponse };
+export { createEffectServerRuntimeErrorResponse };

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

@@ -0,0 +1,152 @@
+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 { resolveOperationProducer } from "@modern-js/server-runtime-extensions/bff-policy/node";
+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 { resolveEffectServerCrossProjectPolicy } from "./cross-project-policy.mjs";
+import { resolveEffectServerEntryFile } from "./entry.mjs";
+import { createEffectServerRuntimeErrorResponse } from "./error-response.mjs";
+const EFFECT_MIDDLEWARE_BEFORE = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+const effect_server = ()=>({
+        name: '@modern-js/plugin-bff-extensions/effect-server',
+        setup (api) {
+            const runtimeFramework = api.getServerContext().bffRuntimeFramework;
+            if ('effect' !== runtimeFramework) throw new Error(`Effect BFF server plugin requires Effect; received "${runtimeFramework}".`);
+            let handler = null;
+            let unregisterRuntimeDisposer;
+            let prefix = '/api';
+            let prefixes = [
+                '/api'
+            ];
+            let matchingPrefixes = [
+                '/api'
+            ];
+            let retired = false;
+            const dispose = async ()=>{
+                retired = true;
+                unregisterRuntimeDisposer?.();
+                unregisterRuntimeDisposer = void 0;
+                const previous = handler;
+                handler = null;
+                await previous?.dispose();
+            };
+            const loadHandler = async ()=>{
+                const entryFile = resolveEffectServerEntryFile(api);
+                if (!entryFile || !await fs.pathExists(entryFile)) {
+                    handler = null;
+                    return;
+                }
+                const { appDirectory } = api.getServerContext();
+                let mod;
+                try {
+                    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 producer = resolveOperationProducer({
+                    directories: [
+                        node_path.dirname(entryFile),
+                        appDirectory
+                    ],
+                    requestId: api.getServerConfig()?.bff?.requestId
+                });
+                const crossProjectPolicies = new Map(await Promise.all(prefixes.map(async (prefix)=>[
+                        prefix,
+                        await resolveEffectServerCrossProjectPolicy(api, prefix, mod, producer)
+                    ])));
+                const effectConfig = api.getServerConfig()?.bff?.effect;
+                const loaded = await resolveEffectBffModuleHandler(mod, {
+                    openapi: effectConfig?.openapi,
+                    dataPlatform: effectConfig?.dataPlatform,
+                    validateRequest: (request)=>{
+                        const { path: mountedPathname } = useEffectContext();
+                        const prefix = 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 (retired) {
+                    await candidate.dispose();
+                    throw new Error('Cannot initialize a retired Effect server.');
+                }
+                handler = candidate;
+            };
+            api.onPrepare(async ()=>{
+                const { middlewares: globalMiddlewares } = api.getServerContext();
+                const configuredPrefix = api.getServerConfig()?.bff?.prefix;
+                const enableHandleWeb = api.getServerConfig()?.bff?.enableHandleWeb;
+                const configuredPrefixes = Array.isArray(configuredPrefix) ? configuredPrefix.filter(Boolean) : [
+                    configuredPrefix || '/api'
+                ];
+                prefixes = [
+                    ...new Set(configuredPrefixes.length > 0 ? configuredPrefixes : [
+                        '/api'
+                    ])
+                ];
+                matchingPrefixes = [
+                    ...prefixes
+                ].sort((left, right)=>right.length - left.length);
+                prefix = prefixes[0] || '/api';
+                const { serverBase } = api.getServerContext();
+                if (serverBase) unregisterRuntimeDisposer = registerServerRuntimeDisposer(serverBase, dispose);
+                try {
+                    await loadHandler();
+                } catch (error) {
+                    await dispose();
+                    throw error;
+                }
+                const middlewarePrefixes = enableHandleWeb ? [
+                    prefix
+                ] : 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 activeHandler = handler;
+                            if (!activeHandler) {
+                                if (enableHandleWeb) return void await next();
+                                return createEffectServerRuntimeErrorResponse(api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), context);
+                            }
+                            const mountedPrefix = enableHandleWeb ? matchingPrefixes.find((item)=>'/' === item || context.req.path === item || context.req.path.startsWith(`${item}/`)) || prefix : middlewarePrefix;
+                            const response = await dispatchEffectBffRequest(activeHandler, context.req.raw, {
+                                prefix: mountedPrefix,
+                                env: context.env,
+                                path: context.req.path,
+                                method: context.req.method,
+                                onError: (error)=>createEffectServerRuntimeErrorResponse(api, error, context)
+                            });
+                            if (404 === response.status && enableHandleWeb) return void await next();
+                            return new Response(response.body, response);
+                        }
+                    }));
+                globalMiddlewares.push(...middlewares);
+            });
+        }
+    });
+export default effect_server;

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

@@ -1,12 +1,11 @@
 import "node:module";
 import { fs, upath } from "@modern-js/utils";
-import { resolveEffectEntryFile } from "./paths.mjs";
-const BUILT_ENTRY_EXT = /\.(?:[cm]?ts|tsx|jsx)$/u;
+import { emittedEffectEntry, relativeEffectAppPath, resolveEffectEntryFile } from "./paths.mjs";
 function resolveBuiltEffectEntry(appDirectory, distDirectory, sourceEntry) {
     if (void 0 === sourceEntry || 0 === sourceEntry.length) return;
-    const relativeEntry = upath.relative(appDirectory, sourceEntry);
-    if ('..' === relativeEntry || relativeEntry.startsWith(`..${upath.sep}`)) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
-    const builtEntry = upath.resolve(distDirectory, relativeEntry).replace(BUILT_ENTRY_EXT, '.js');
+    const relativeEntry = relativeEffectAppPath(appDirectory, sourceEntry);
+    if (void 0 === relativeEntry) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
+    const builtEntry = emittedEffectEntry(upath.resolve(distDirectory, relativeEntry));
     return fs.existsSync(builtEntry) ? builtEntry : void 0;
 }
 async function bundleBuiltEffectEntryForNode(options) {
@@ -32,7 +31,7 @@ function resolveEffectEntryPaths(options) {
         apiDir,
         effectEntry
     });
-    const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? upath.relative(appDir, sourceEffectEntry).replace(BUILT_ENTRY_EXT, '.js') : '';
+    const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? emittedEffectEntry(upath.relative(appDir, sourceEffectEntry)) : '';
     return {
         sourceEffectEntry,
         relativeEffectEntry

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

@@ -131,7 +131,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,

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

@@ -1,46 +1,23 @@
 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 { 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";
-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)
+        ...resolveOperationProducer({
+            directories: [
+                upath.dirname(options.resourcePath),
+                options.appDir
+            ],
+            requestId: options.requestId,
+            onDependency: options.onDependency
+        })
     });
 }
 export { resolveEffectOperationContracts };

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

@@ -10,16 +10,35 @@ const JS_OR_TS_EXTS = [
     '.cjs',
     '.cts'
 ];
-function resolveEffectEntryFile(options) {
-    const { appDir, apiDir, effectEntry } = options;
-    const resolveEntry = (entryWithoutExt)=>{
-        if ('' !== upath.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
-        return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`)) || void 0;
+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)
     };
-    if (void 0 !== effectEntry && '' !== effectEntry) {
-        const entryWithoutExt = upath.isAbsolute(effectEntry) ? effectEntry : upath.resolve(appDir, effectEntry);
-        return resolveEntry(entryWithoutExt);
-    }
-    return resolveEntry(upath.resolve(apiDir, 'index'));
+    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 { resolveEffectEntryFile };
+export { emittedEffectEntry, relativeEffectAppPath, resolveEffectEntry, resolveEffectEntryFile };

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

@@ -11,11 +11,8 @@ 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.
- */
+/** Decode independently at each received-manifest / executed-expose boundary. */
+export declare function backendFederationCompatibility(loaded: unknown): Record<string, unknown> | undefined;
+export declare function validateBackendFederationCompatibility(compatibility: Record<string, unknown>, expected: Record<string, string | undefined>): BackendFederationIdentityIssue[];
 export declare function validateExpectedBackendFederationIdentity(loaded: unknown, expected: BackendFederationExpectedIdentity): BackendFederationIdentityIssue[];
 export declare function formatBackendFederationIdentityIssues(issues: BackendFederationIdentityIssue[]): string;

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

@@ -0,0 +1,2 @@
+import { evaluateNodeBackendFederationCommonJs } from '@modern-js/server-runtime-extensions/backend-federation-security/node';
+export declare const evaluateEffectBackendFederationCommonJs: (source: Parameters<typeof evaluateNodeBackendFederationCommonJs>[0], context: Parameters<typeof evaluateNodeBackendFederationCommonJs>[1]) => Record<string, unknown>;

package/dist/types/cross-project-policy/node.d.ts

@@ -1,5 +1,5 @@
 import '@modern-js/server-runtime-extensions/server-config';
 import type { ServerPluginAPI } from '@modern-js/server-core';
-import { type OperationContractSource } from '@modern-js/server-runtime-extensions/bff-policy/node';
+import { type OperationContractSource, resolveOperationProducer } from '@modern-js/server-runtime-extensions/bff-policy/node';
 import type { ResolvedCrossProjectPolicy } from './evaluation.js';
-export declare const resolveAdapterCrossProjectPolicy: (api: ServerPluginAPI, handlers: OperationContractSource[]) => ResolvedCrossProjectPolicy | undefined;
+export declare const resolveAdapterCrossProjectPolicy: (api: ServerPluginAPI, handlers: OperationContractSource[], producer?: ReturnType<typeof resolveOperationProducer>) => ResolvedCrossProjectPolicy | undefined;

package/dist/types/effect-server/cross-project-policy.d.ts

@@ -0,0 +1,5 @@
+import { type EffectApiModule } from '@modern-js/bff-effect/effect';
+import type { ServerPluginAPI } from '@modern-js/server-core';
+import type { resolveOperationProducer } from '@modern-js/server-runtime-extensions/bff-policy/node';
+import type { ResolvedCrossProjectPolicy } from '../cross-project-policy/evaluation.js';
+export declare function resolveEffectServerCrossProjectPolicy(api: ServerPluginAPI, prefix: string, mod: EffectApiModule | null, producer?: ReturnType<typeof resolveOperationProducer>): Promise<ResolvedCrossProjectPolicy | undefined>;

package/dist/types/{effect-adapter → effect-server}/entry.d.ts

@@ -1,3 +1,3 @@
 import '@modern-js/server-runtime-extensions/server-config';
 import type { ServerPluginAPI } from '@modern-js/server-core';
-export declare function resolveEffectAdapterEntryFile(api: ServerPluginAPI): string | undefined;
+export declare function resolveEffectServerEntryFile(api: ServerPluginAPI): string | undefined;

package/dist/types/effect-server/error-response.d.ts

@@ -0,0 +1,2 @@
+import type { Context, ServerPluginAPI } from '@modern-js/server-core';
+export declare function createEffectServerRuntimeErrorResponse(api: ServerPluginAPI, error: unknown, context: Context): Promise<Response>;

package/dist/types/effect-server/index.d.ts

@@ -0,0 +1,4 @@
+import '@modern-js/server-runtime-extensions/server-config';
+import type { ServerPlugin } from '@modern-js/server-core';
+export default _default;
+declare function _default(): ServerPlugin;

package/dist/types/effect-source-loader/paths.d.ts

@@ -1,5 +1,23 @@
-export declare function resolveEffectEntryFile(options: {
+export declare const emittedEffectEntry: (entry: string) => string;
+export declare function relativeEffectAppPath(appDir: string, entry: string): string | undefined;
+type EffectEntryOptions = {
     appDir: string;
     apiDir: string;
     effectEntry?: string;
-}): string | undefined;
+};
+export type EffectEntry = {
+    kind: 'app-source';
+    path: string | undefined;
+} | {
+    kind: 'built-output';
+    path: string | undefined;
+} | {
+    kind: 'external-sdk';
+    path: string | undefined;
+};
+/** Classify ownership before resolving files: production works without source. */
+export declare function resolveEffectEntry(options: EffectEntryOptions & {
+    distDir?: string;
+}): EffectEntry;
+export declare function resolveEffectEntryFile(options: EffectEntryOptions): string | undefined;
+export {};