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

package/README.md

@@ -21,6 +21,13 @@ upstream Modern.js project.
 - `/backend-federation-manifest` exposes manifest contracts and resolution,
   while
   `/backend-federation-manifest/node` enables its hardened Node evaluator.
+  `loadBackendFederatedEffectApiFromManifest` enforces one shared
+  manifest-plus-entry load deadline (default 10s, override via `timeoutMs`,
+  0 to opt out) instead of resetting a fresh timeout per network hop. The
+  load settles on that shared deadline/abort even when a caller-pinned
+  `loadEntry` plugin, its `init`/`get`, or a custom runtime's `loadRemote`
+  never settles; it cannot stop that uncooperative work from still running,
+  only stop waiting on it.
 
 Effect and its OpenTelemetry integration are exact-cohort optional peers. A
 Hono-only consumer can import `/hono` without installing Effect.

package/dist/cjs/backend-federation/identity.js

@@ -28,47 +28,48 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    backendFederationCompatibility: ()=>backendFederationCompatibility,
     formatBackendFederationIdentityIssues: ()=>formatBackendFederationIdentityIssues,
+    validateBackendFederationCompatibility: ()=>validateBackendFederationCompatibility,
     validateExpectedBackendFederationIdentity: ()=>validateExpectedBackendFederationIdentity
 });
 const external_utils_js_namespaceObject = require("./utils.js");
-function validateExpectedBackendFederationIdentity(loaded, expected) {
-    const issues = [];
+function backendFederationCompatibility(loaded) {
     const contract = (0, external_utils_js_namespaceObject.isRecord)(loaded) ? loaded.backendFederationContract : void 0;
     const compatibility = (0, external_utils_js_namespaceObject.isRecord)(contract) ? contract.compatibility : void 0;
-    if (!(0, external_utils_js_namespaceObject.isRecord)(compatibility)) return [
+    return (0, external_utils_js_namespaceObject.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('; ');
 }
+exports.backendFederationCompatibility = __webpack_exports__.backendFederationCompatibility;
 exports.formatBackendFederationIdentityIssues = __webpack_exports__.formatBackendFederationIdentityIssues;
+exports.validateBackendFederationCompatibility = __webpack_exports__.validateBackendFederationCompatibility;
 exports.validateExpectedBackendFederationIdentity = __webpack_exports__.validateExpectedBackendFederationIdentity;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "backendFederationCompatibility",
     "formatBackendFederationIdentityIssues",
+    "validateBackendFederationCompatibility",
     "validateExpectedBackendFederationIdentity"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/backend-federation-manifest/load.js

@@ -37,6 +37,7 @@ const external_metadata_js_namespaceObject = require("./metadata.js");
 const external_reference_js_namespaceObject = require("./reference.js");
 const external_remote_js_namespaceObject = require("./remote.js");
 const external_validation_js_namespaceObject = require("./validation.js");
+const DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS = 10000;
 function createManifestLoadScope(options) {
     const controller = new AbortController();
     const policyTimeouts = [
@@ -48,7 +49,8 @@ function createManifestLoadScope(options) {
         ...policyTimeouts
     ].filter((timeout)=>void 0 !== timeout);
     for (const timeout of configuredTimeouts)if (!Number.isSafeInteger(timeout) || timeout < 0) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', '[BFF][Effect] Backend federation timeoutMs must be a non-negative safe integer.');
-    const timeoutMs = options.timeoutMs ?? (policyTimeouts.length > 0 ? Math.min(...policyTimeouts) : 0);
+    const positivePolicyTimeouts = policyTimeouts.filter((timeout)=>timeout > 0);
+    const timeoutMs = options.timeoutMs ?? (0 === policyTimeouts.length ? DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS : positivePolicyTimeouts.length > 0 ? Math.min(...positivePolicyTimeouts) : 0);
     const inputSignals = [
         options.signal,
         options.manifestPolicy?.signal,
@@ -102,6 +104,27 @@ function isCallerPinnedStaticRemote(options, remote) {
 function throwIfManifestLoadAborted(signal) {
     if (signal.aborted) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('remote_unavailable', '[BFF][Effect] Backend federation load was aborted before remote execution.', signal.reason);
 }
+function settleOnSharedAbort(promise, signal) {
+    if (signal.aborted) {
+        promise.catch(()=>{});
+        throwIfManifestLoadAborted(signal);
+    }
+    let onAbort;
+    const aborted = new Promise((_resolve, reject)=>{
+        onAbort = ()=>{
+            reject(new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('remote_unavailable', '[BFF][Effect] Backend federation load was aborted before remote execution.', signal.reason));
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+    });
+    return Promise.race([
+        promise,
+        aborted
+    ]).finally(()=>{
+        if (onAbort) signal.removeEventListener('abort', onAbort);
+    });
+}
 async function loadBackendFederatedEffectApiFromManifest(options) {
     let manifest;
     let remote;
@@ -109,7 +132,7 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
     try {
         scope = createManifestLoadScope(options);
         throwIfManifestLoadAborted(scope.signal);
-        manifest = await (0, external_reference_js_namespaceObject.loadBackendFederationManifest)({
+        manifest = await settleOnSharedAbort((0, external_reference_js_namespaceObject.loadBackendFederationManifest)({
             ...options,
             manifestPolicy: {
                 ...options.manifestPolicy,
@@ -118,7 +141,7 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
             },
             signal: scope.signal,
             timeoutMs: 0
-        });
+        }), scope.signal);
         (0, external_validation_js_namespaceObject.validateBackendFederationManifest)(manifest, options.expected);
         remote = (0, external_remote_js_namespaceObject.resolveBackendFederationRemoteFromManifest)(manifest, options.remote);
         throwIfManifestLoadAborted(scope.signal);
@@ -132,7 +155,7 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
         const unitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
         const buildMarker = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker);
         if (!unitId || !buildMarker) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', 'Backend federation manifest requires delivery-unit identity.');
-        const loaded = await (0, load_js_namespaceObject.loadBackendFederatedEffectApi)({
+        const loaded = await settleOnSharedAbort((0, load_js_namespaceObject.loadBackendFederatedEffectApi)({
             hostName: options.hostName,
             remote,
             ...options.plugins ? {
@@ -152,7 +175,7 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
             }
         }).catch((error)=>{
             throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError(scope?.timedOut() === true ? 'timeout' : (0, external_validation_js_namespaceObject.classifyLoadError)(error), `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? index_js_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE}.`, error);
-        });
+        }), scope.signal);
         (0, external_validation_js_namespaceObject.validateLoadedBackendFederationContract)(loaded, manifest, remote);
         return loaded;
     } catch (error) {

package/dist/cjs/backend-federation-manifest/validation.js

@@ -34,6 +34,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const index_js_namespaceObject = require("../backend-federation/index.js");
+const identity_js_namespaceObject = require("../backend-federation/identity.js");
 const external_errors_js_namespaceObject = require("./errors.js");
 const external_metadata_js_namespaceObject = require("./metadata.js");
 function resolveExpectedBuildMarker(expected) {
@@ -76,19 +77,22 @@ function validateLoadedBackendFederationContract(loaded, manifest, remote) {
     const loadedContract = loaded.backendFederationContract;
     const backendFederation = (0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest);
     const boundary = (0, external_metadata_js_namespaceObject.versionBoundaryMetadata)(manifest);
-    const compatibility = (0, external_metadata_js_namespaceObject.recordField)(loadedContract, 'compatibility');
+    const compatibility = (0, identity_js_namespaceObject.backendFederationCompatibility)(loaded);
     (0, external_errors_js_namespaceObject.assertManifestAdapter)(compatibility, 'version_mismatch', `[BFF][Effect] Backend federation expose ${remote.name}/${remote.expose?.replace(/^\.\//u, '')} must declare compatibility metadata.`);
     (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(loadedContract?.role), 'microvertical-server', 'expose role');
     (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(loadedContract?.name), remote.name, 'expose name');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.contractVersion), (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.contractVersion), 'expose contractVersion');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.nodeAdapterVersion), (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.nodeAdapterVersion), 'expose nodeAdapterVersion');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.packageName), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName), 'expose packageName');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'expose buildVersion');
     const deliveryUnit = (0, external_metadata_js_namespaceObject.manifestDeliveryUnit)(backendFederation, boundary);
     const manifestUnitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
     const manifestBuildMarker = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker);
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.unitId), manifestUnitId, 'deliveryUnit.unitId vs expose compatibility.unitId');
-    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), manifestBuildMarker, 'deliveryUnit.buildMarker vs expose compatibility.build');
+    const issues = (0, identity_js_namespaceObject.validateBackendFederationCompatibility)(compatibility, {
+        contractVersion: (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.contractVersion),
+        nodeAdapterVersion: (0, external_metadata_js_namespaceObject.stringValue)(backendFederation?.nodeAdapterVersion),
+        packageName: (0, external_metadata_js_namespaceObject.stringValue)(boundary?.packageName),
+        unitId: manifestUnitId,
+        build: manifestBuildMarker ?? (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion)
+    });
+    (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'expose buildVersion');
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(0 === issues.length, 'version_mismatch', `[BFF][Effect] ${(0, identity_js_namespaceObject.formatBackendFederationIdentityIssues)(issues)}.`);
 }
 function classifyLoadError(error) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/cjs/cross-project-policy/node.js

@@ -1,14 +1,5 @@
 "use strict";
 var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -39,33 +30,22 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     resolveAdapterCrossProjectPolicy: ()=>resolveAdapterCrossProjectPolicy
 });
-const external_node_fs_namespaceObject = require("node:fs");
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 require("@modern-js/server-runtime-extensions/server-config");
 const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
-const readNearestPackageVersion = (startDir)=>{
-    if (!startDir) return;
-    let current = external_node_path_default().resolve(startDir);
-    for(let depth = 0; depth < 10; depth += 1){
-        try {
-            const packageJson = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(external_node_path_default().join(current, 'package.json'), 'utf8'));
-            if ('string' == typeof packageJson.version) return packageJson.version;
-        } catch  {}
-        const parent = external_node_path_default().dirname(current);
-        if (parent === current) break;
-        current = parent;
-    }
-};
-const resolveAdapterCrossProjectPolicy = (api, handlers)=>{
+const resolveAdapterCrossProjectPolicy = (api, handlers, producer)=>{
     const bff = api.getServerConfig()?.bff;
     const { apiDirectory, appDirectory } = api.getServerContext();
     return (0, node_namespaceObject.resolveCrossProjectPolicy)({
         crossProjectPolicy: bff?.crossProjectPolicy,
         handlers,
-        requestId: bff?.requestId,
         isCrossProjectServer: bff?.isCrossProjectServer,
-        operationVersion: (0, node_namespaceObject.deriveOperationVersion)(readNearestPackageVersion(apiDirectory) ?? readNearestPackageVersion(appDirectory))
+        ...producer ?? (0, node_namespaceObject.resolveOperationProducer)({
+            directories: [
+                apiDirectory,
+                appDirectory
+            ],
+            requestId: bff?.requestId || 'default'
+        })
     });
 };
 exports.resolveAdapterCrossProjectPolicy = __webpack_exports__.resolveAdapterCrossProjectPolicy;

package/dist/cjs/effect-adapter/cross-project-policy.js

@@ -34,7 +34,7 @@ const effect_namespaceObject = require("@modern-js/bff-effect/effect");
 const utils_namespaceObject = require("@modern-js/utils");
 const httpapi_namespaceObject = require("effect/unstable/httpapi");
 const index_js_namespaceObject = require("../cross-project-policy/index.js");
-function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
+function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod, producer) {
     const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>(0, effect_namespaceObject.extractHttpApiFromModule)(mod, httpapi_namespaceObject.HttpApi.isHttpApi)).then((effectApi)=>{
         if (null === effectApi) return [];
         const reflect = (apiValue, handlers)=>{
@@ -50,7 +50,7 @@ function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
         return [];
     });
     return contractSourcesPromise.then((contractSources)=>{
-        const policy = (0, index_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources);
+        const policy = (0, index_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources, producer);
         if (policy?.enabled === true && 0 === contractSources.length) utils_namespaceObject.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;
     });

package/dist/cjs/effect-adapter/entry.js

@@ -43,52 +43,16 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 require("@modern-js/server-runtime-extensions/server-config");
 const utils_namespaceObject = require("@modern-js/utils");
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-function resolveJsOrTsEntry(entryWithoutOrWithExt) {
-    const extension = external_node_path_default().extname(entryWithoutOrWithExt);
-    if (JS_OR_TS_EXTS.includes(extension)) return utils_namespaceObject.fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
-    return (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutOrWithExt}${ext}`)) || void 0;
-}
-function builtEntryPath(entryPath) {
-    return entryPath.replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
-}
-function relativeAppPath(appDirectory, entryPath) {
-    const relativePath = external_node_path_default().relative(appDirectory, entryPath);
-    return '..' === relativePath || relativePath.startsWith(`..${external_node_path_default().sep}`) ? void 0 : relativePath;
-}
-function isDependencyPath(relativePath) {
-    return relativePath?.split(/[\\/]/u).includes('node_modules') ?? false;
-}
+const paths_js_namespaceObject = require("../effect-source-loader/paths.js");
 function resolveEffectAdapterEntryFile(api) {
     const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
-    const appRoot = external_node_path_default().resolve(appDirectory || process.cwd());
-    const productionRoot = (0, utils_namespaceObject.isProd)() && distDirectory ? external_node_path_default().resolve(distDirectory) : void 0;
-    const configuredEntry = api.getServerConfig()?.bff?.effect?.entry;
-    if (configuredEntry) {
-        const sourceEntry = external_node_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_node_path_default().resolve(appRoot, configuredEntry);
-        if (productionRoot) {
-            const relativeEntry = relativeAppPath(appRoot, sourceEntry);
-            if (void 0 === relativeEntry || isDependencyPath(relativeEntry)) return resolveJsOrTsEntry(sourceEntry);
-            return relativeEntry ? resolveJsOrTsEntry(builtEntryPath(external_node_path_default().resolve(productionRoot, relativeEntry))) : void 0;
-        }
-        return resolveJsOrTsEntry(sourceEntry);
-    }
-    const resolvedApiDirectory = external_node_path_default().resolve(appRoot, apiDirectory || utils_namespaceObject.API_DIR);
-    const productionApiDirectory = productionRoot ? void 0 !== relativeAppPath(productionRoot, resolvedApiDirectory) ? resolvedApiDirectory : (()=>{
-        const relativeApiDirectory = relativeAppPath(appRoot, resolvedApiDirectory);
-        if (isDependencyPath(relativeApiDirectory)) return resolvedApiDirectory;
-        return relativeApiDirectory ? external_node_path_default().resolve(productionRoot, relativeApiDirectory) : void 0;
-    })() : resolvedApiDirectory;
-    return productionApiDirectory ? resolveJsOrTsEntry(external_node_path_default().resolve(productionApiDirectory, 'index')) : void 0;
+    const appDir = external_node_path_default().resolve(appDirectory || process.cwd());
+    return (0, paths_js_namespaceObject.resolveEffectEntry)({
+        appDir,
+        apiDir: external_node_path_default().resolve(appDir, apiDirectory || utils_namespaceObject.API_DIR),
+        effectEntry: api.getServerConfig()?.bff?.effect?.entry,
+        distDir: (0, utils_namespaceObject.isProd)() && distDirectory ? external_node_path_default().resolve(distDirectory) : void 0
+    }).path;
 }
 exports.resolveEffectAdapterEntryFile = __webpack_exports__.resolveEffectAdapterEntryFile;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/effect-adapter/index.js

@@ -44,6 +44,7 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 require("@modern-js/server-runtime-extensions/server-config");
 const effect_namespaceObject = require("@modern-js/bff-effect/effect");
+const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
 const runtime_lifecycle_namespaceObject = require("@modern-js/server-runtime-extensions/runtime-lifecycle");
 const utils_namespaceObject = require("@modern-js/utils");
 const evaluation_js_namespaceObject = require("../cross-project-policy/evaluation.js");
@@ -63,9 +64,9 @@ class EffectAdapter {
             this.handler = null;
             return;
         }
+        const { appDirectory } = this.api.getServerContext();
         let mod;
         try {
-            const { appDirectory } = this.api.getServerContext();
             mod = await ((0, utils_namespaceObject.isProd)() ? (0, loader_js_namespaceObject.loadEffectBuiltModule)(entryFile) : (0, loader_js_namespaceObject.loadEffectSourceModule)({
                 resourcePath: entryFile,
                 appDir: appDirectory || external_node_path_default().dirname(entryFile)
@@ -74,9 +75,16 @@ class EffectAdapter {
             utils_namespaceObject.logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
             throw error;
         }
+        const producer = (0, node_namespaceObject.resolveOperationProducer)({
+            directories: [
+                external_node_path_default().dirname(entryFile),
+                appDirectory
+            ],
+            requestId: this.api.getServerConfig()?.bff?.requestId
+        });
         const crossProjectPolicies = new Map(await Promise.all(this.prefixes.map(async (prefix)=>[
                 prefix,
-                await (0, external_cross_project_policy_js_namespaceObject.resolveEffectAdapterCrossProjectPolicy)(this.api, prefix, mod)
+                await (0, external_cross_project_policy_js_namespaceObject.resolveEffectAdapterCrossProjectPolicy)(this.api, prefix, mod, producer)
             ])));
         const effectConfig = this.api.getServerConfig()?.bff?.effect;
         const loaded = await (0, effect_namespaceObject.resolveEffectBffModuleHandler)(mod, {

package/dist/cjs/effect-source-loader/built-entry.js

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

package/dist/cjs/effect-source-loader/loader.js

@@ -176,7 +176,8 @@ function externalizeInstalledDependencies(options) {
                     path: args.path
                 };
                 const realPath = await external_node_fs_default().promises.realpath(resolution.path).catch(()=>resolution.path);
-                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`)) {
+                const loader = SOURCE_LOADERS.get(external_node_path_default().extname(realPath).toLowerCase());
+                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`) && 'ts' !== loader && 'tsx' !== loader && 'jsx' !== loader) {
                     const runtimeResolution = await buildApi.resolve(args.path, {
                         importer: '',
                         kind: args.kind,

package/dist/cjs/effect-source-loader/operation-contracts.js

@@ -34,44 +34,21 @@ const effect_namespaceObject = require("@modern-js/bff-effect/effect");
 const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_http_api_runtime_js_namespaceObject = require("./http-api-runtime.js");
-function getPackageInfo(resourcePath, appDir, onDependency) {
-    for (const startDir of [
-        utils_namespaceObject.upath.dirname(resourcePath),
-        appDir
-    ]){
-        let current = utils_namespaceObject.upath.resolve(startDir);
-        for(let depth = 0; depth < 32; depth += 1){
-            const packageJsonPath = utils_namespaceObject.upath.join(current, 'package.json');
-            if (utils_namespaceObject.fs.existsSync(packageJsonPath)) {
-                onDependency?.(packageJsonPath);
-                try {
-                    const packageJson = utils_namespaceObject.fs.readJSONSync(packageJsonPath);
-                    return {
-                        name: packageJson.name,
-                        version: packageJson.version
-                    };
-                } catch  {
-                    return {};
-                }
-            }
-            const parent = utils_namespaceObject.upath.dirname(current);
-            if (parent === current) break;
-            current = parent;
-        }
-    }
-    return {};
-}
 async function resolveEffectOperationContracts(options) {
     const api = await (0, external_http_api_runtime_js_namespaceObject.loadEffectApi)(options);
     if (null === api) return null;
     const runtime = await (0, external_http_api_runtime_js_namespaceObject.getHttpApiRuntime)();
     const endpoints = (0, effect_namespaceObject.collectEffectEndpoints)(runtime.reflect, api, options.prefix);
-    const packageInfo = getPackageInfo(options.resourcePath, options.appDir, options.onDependency);
-    const requestId = options.requestId?.trim() || packageInfo.name || 'default';
     return (0, node_namespaceObject.buildOperationContractMap)({
         handlers: (0, effect_namespaceObject.toOperationContractSources)(endpoints),
-        requestId,
-        operationVersion: (0, node_namespaceObject.deriveOperationVersion)(packageInfo.version)
+        ...(0, node_namespaceObject.resolveOperationProducer)({
+            directories: [
+                utils_namespaceObject.upath.dirname(options.resourcePath),
+                options.appDir
+            ],
+            requestId: options.requestId,
+            onDependency: options.onDependency
+        })
     });
 }
 exports.resolveEffectOperationContracts = __webpack_exports__.resolveEffectOperationContracts;

package/dist/cjs/effect-source-loader/paths.js

@@ -28,6 +28,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    emittedEffectEntry: ()=>emittedEffectEntry,
+    relativeEffectAppPath: ()=>relativeEffectAppPath,
+    resolveEffectEntry: ()=>resolveEffectEntry,
     resolveEffectEntryFile: ()=>resolveEffectEntryFile
 });
 const utils_namespaceObject = require("@modern-js/utils");
@@ -41,20 +44,45 @@ const JS_OR_TS_EXTS = [
     '.cjs',
     '.cts'
 ];
-function resolveEffectEntryFile(options) {
-    const { appDir, apiDir, effectEntry } = options;
-    const resolveEntry = (entryWithoutExt)=>{
-        if ('' !== utils_namespaceObject.upath.extname(entryWithoutExt)) return utils_namespaceObject.fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
-        return (0, utils_namespaceObject.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 = utils_namespaceObject.upath.relative(appDir, entry);
+    return '..' === relative || relative.startsWith('../') || relative.split('/').includes('node_modules') ? void 0 : relative;
+}
+function existingEntry(entry) {
+    return utils_namespaceObject.upath.extname(entry) ? utils_namespaceObject.fs.existsSync(entry) ? entry : void 0 : (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entry}${ext}`)) || void 0;
+}
+function resolveEffectEntry(options) {
+    const { appDir, apiDir, effectEntry, distDir } = options;
+    const entry = utils_namespaceObject.upath.resolve(appDir, effectEntry || utils_namespaceObject.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 = utils_namespaceObject.upath.isAbsolute(effectEntry) ? effectEntry : utils_namespaceObject.upath.resolve(appDir, effectEntry);
-        return resolveEntry(entryWithoutExt);
-    }
-    return resolveEntry(utils_namespaceObject.upath.resolve(apiDir, 'index'));
+    return distDir ? {
+        kind: 'built-output',
+        path: existingEntry(emittedEffectEntry(utils_namespaceObject.upath.resolve(distDir, relative)))
+    } : {
+        kind: 'app-source',
+        path: existingEntry(entry)
+    };
+}
+function resolveEffectEntryFile(options) {
+    return resolveEffectEntry(options).path;
 }
+exports.emittedEffectEntry = __webpack_exports__.emittedEffectEntry;
+exports.relativeEffectAppPath = __webpack_exports__.relativeEffectAppPath;
+exports.resolveEffectEntry = __webpack_exports__.resolveEffectEntry;
 exports.resolveEffectEntryFile = __webpack_exports__.resolveEffectEntryFile;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "emittedEffectEntry",
+    "relativeEffectAppPath",
+    "resolveEffectEntry",
     "resolveEffectEntryFile"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -1,35 +1,30 @@
 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 };