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

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

@@ -0,0 +1,67 @@
+import "node:module";
+import { formatBackendFederationValidationErrors, validateBackendFederationManifest } from "@modern-js/utils/universal";
+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";
+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',
+        expected: expected.buildVersion,
+        received: expected.buildMarker
+    });
+    return expected.buildMarker;
+}
+function validation_validateBackendFederationManifest(manifest, expected = {}) {
+    const expectedBuildMarker = resolveExpectedBuildMarker(expected);
+    const backendFederation = backendFederationMetadata(manifest);
+    assertManifestAdapter(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
+    const manifestShape = validateBackendFederationManifest(manifest, {
+        expectedContractVersion: false,
+        expectedNodeAdapterVersion: false,
+        validateDeliveryUnit: 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".');
+    assertManifestAdapter(true === backendFederation.strictEffectApproach, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare strictEffectApproach: true.');
+    assertVersionValue(stringValue(backendFederation.contractVersion), expected.contractVersion ?? BACKEND_FEDERATION_CONTRACT_VERSION, 'manifest contractVersion');
+    assertVersionValue(stringValue(backendFederation.nodeAdapterVersion), expected.nodeAdapterVersion ?? BACKEND_FEDERATION_NODE_ADAPTER_VERSION, 'manifest nodeAdapterVersion');
+    const boundary = versionBoundaryMetadata(manifest);
+    assertVersionValue(stringValue(backendFederation.name) ?? stringValue(manifest.name) ?? stringValue(manifest.id), expected.remoteName, 'manifest remoteName');
+    assertVersionValue(stringValue(boundary?.packageName), expected.packageName, 'versionBoundary.packageName');
+    assertVersionValue(stringValue(boundary?.version), expected.version, 'versionBoundary.version');
+    assertVersionValue(stringValue(boundary?.buildVersion), expected.buildVersion, 'versionBoundary.buildVersion');
+    assertConsistentValue(stringValue(manifest.version), stringValue(boundary?.version), 'manifest versionBoundary.version');
+    assertConsistentValue(stringValue(manifest.buildVersion), stringValue(boundary?.buildVersion), 'manifest versionBoundary.buildVersion');
+    const deliveryUnit = manifestDeliveryUnit(backendFederation, boundary);
+    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);
+    assertVersionValue(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
+    assertVersionValue(stringValue(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
+}
+function validateLoadedBackendFederationContract(loaded, manifest, remote) {
+    const loadedContract = loaded.backendFederationContract;
+    const backendFederation = backendFederationMetadata(manifest);
+    const boundary = versionBoundaryMetadata(manifest);
+    const compatibility = recordField(loadedContract, 'compatibility');
+    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);
+    assertConsistentValue(manifestUnitId, stringValue(compatibility.unitId), 'deliveryUnit.unitId vs expose compatibility.unitId');
+    assertConsistentValue(manifestBuildMarker, stringValue(compatibility.build), 'deliveryUnit.buildMarker vs expose compatibility.build');
+}
+function classifyLoadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if ('object' == typeof error && null !== error && 'code' in error && 'timeout' === error.code || /timed out/iu.test(message)) return 'timeout';
+    if (message.includes('delivery-unit identity mismatch')) return 'version_mismatch';
+    if (message.includes('strictEffectApproach') || message.includes('runtimeFramework')) return 'strict_effect_required';
+    return 'remote_unavailable';
+}
+export { classifyLoadError, validateLoadedBackendFederationContract, validation_validateBackendFederationManifest as validateBackendFederationManifest };

package/dist/esm-node/client-generator/built-entry.mjs

@@ -0,0 +1,41 @@
+import "node:module";
+import { fs, upath } from "@modern-js/utils";
+import { resolveEffectEntryFile } from "./paths.mjs";
+const BUILT_ENTRY_EXT = /\.(?:[cm]?ts|tsx|jsx)$/u;
+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');
+    return fs.existsSync(builtEntry) ? builtEntry : void 0;
+}
+async function bundleBuiltEffectEntryForNode(options) {
+    const { appDir, apiDir, distDir, effectEntry, format } = options;
+    const sourceEntry = resolveEffectEntryFile({
+        appDir,
+        apiDir,
+        effectEntry
+    });
+    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");
+    return bundleEffectEntryForNode({
+        appDir,
+        entryPath: builtEntry,
+        format
+    });
+}
+function resolveEffectEntryPaths(options) {
+    const { appDir, apiDir, effectEntry } = options;
+    const sourceEffectEntry = resolveEffectEntryFile({
+        appDir,
+        apiDir,
+        effectEntry
+    });
+    const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? upath.relative(appDir, sourceEffectEntry).replace(BUILT_ENTRY_EXT, '.js') : '';
+    return {
+        sourceEffectEntry,
+        relativeEffectEntry
+    };
+}
+export { bundleBuiltEffectEntryForNode, resolveBuiltEffectEntry, resolveEffectEntryPaths };

package/dist/esm-node/client-generator/generator.mjs

@@ -0,0 +1,33 @@
+import "node:module";
+import { collectEffectEndpoints } from "@modern-js/bff-effect/effect";
+import { logger } from "@modern-js/utils";
+import { createEffectClientGeneration, renderEffectClientCode, renderEffectClientDeclaration } from "./rendering.mjs";
+import { getHttpApiRuntime, loadEffectApi } from "./runtime.mjs";
+function generateEffectClient(options) {
+    return loadEffectApi({
+        appDir: options.appDir,
+        resourcePath: options.resourcePath,
+        onDependency: options.onDependency
+    }).then((api)=>{
+        if (null === api) {
+            logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
+            return null;
+        }
+        return getHttpApiRuntime().then((httpApiRuntime)=>{
+            const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
+            const generation = createEffectClientGeneration(endpoints, options);
+            return {
+                code: renderEffectClientCode(generation),
+                declaration: renderEffectClientDeclaration(endpoints),
+                endpoints,
+                operationContracts: generation.operationContracts,
+                operationVersion: generation.operationVersion,
+                requestId: generation.requestId
+            };
+        });
+    });
+}
+function generateEffectClientCode(options) {
+    return generateEffectClient(options).then((artifacts)=>null === artifacts ? null : artifacts.code);
+}
+export { generateEffectClient, generateEffectClientCode };

package/dist/esm-node/client-generator/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { bundleBuiltEffectEntryForNode, resolveEffectEntryPaths } from "./built-entry.mjs";
+export { generateEffectClient, generateEffectClientCode } from "./generator.mjs";
+export { resolveEffectEntryFile } from "./paths.mjs";

package/dist/esm-node/client-generator/paths.mjs

@@ -0,0 +1,25 @@
+import "node:module";
+import { findExists, fs, upath } from "@modern-js/utils";
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.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;
+    };
+    if (void 0 !== effectEntry && '' !== effectEntry) {
+        const entryWithoutExt = upath.isAbsolute(effectEntry) ? effectEntry : upath.resolve(appDir, effectEntry);
+        return resolveEntry(entryWithoutExt);
+    }
+    return resolveEntry(upath.resolve(apiDir, 'index'));
+}
+export { resolveEffectEntryFile };

package/dist/esm-node/client-generator/rendering.mjs

@@ -0,0 +1,210 @@
+import "node:module";
+import { buildOperationContractMap, deriveOperationVersion } from "@modern-js/bff-core";
+import { createEffectEndpointContractHash, ensureLeadingSlash, normalizeEffectPrefix, toOperationContractSources } from "@modern-js/bff-effect/effect";
+import { fs, upath } from "@modern-js/utils";
+const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
+const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
+function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function resolveBatchEndpoint(prefix, endpoint) {
+    const value = void 0 === endpoint || '' === endpoint ? '/_data/batch' : endpoint;
+    if (isAbsoluteUrl(value)) return value;
+    const normalizedPrefix = normalizeEffectPrefix(prefix);
+    const normalizedEndpoint = ensureLeadingSlash(value);
+    if ('' === normalizedPrefix) return normalizedEndpoint;
+    if (normalizedEndpoint === normalizedPrefix || normalizedEndpoint.startsWith(`${normalizedPrefix}/`)) return normalizedEndpoint;
+    return `${normalizedPrefix}${'/' === normalizedEndpoint ? '' : normalizedEndpoint}`;
+}
+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 {};
+}
+function renderEffectClientCode(generation) {
+    const { config, manifest } = generation;
+    return `import * as __requestRuntime from ${JSON.stringify(generation.requestCreator)};
+import { createGeneratedEffectClient } from ${JSON.stringify(EFFECT_CLIENT_RUNTIME_IMPORT)};
+
+const __manifest = ${JSON.stringify(manifest, null, 2)};
+
+const __config = ${JSON.stringify(config, null, 2)};
+
+const __generated = createGeneratedEffectClient(__manifest, __config, __requestRuntime);
+
+const client = __generated.client;
+const operationManifest = __generated.operationManifest;
+const createEffectRequestContext = __generated.createEffectRequestContext;
+const apiModule = {
+  client,
+  operationManifest,
+  createEffectRequestContext,
+};
+
+export { client, createEffectRequestContext, operationManifest };
+export default apiModule;
+`;
+}
+function createEffectClientGeneration(endpoints, options) {
+    const requestCreator = options.requestCreator || DEFAULT_REQUEST_CREATOR;
+    const httpMethodDecider = options.httpMethodDecider || 'functionName';
+    const packageInfo = getPackageInfo(options.resourcePath, options.appDir, options.onDependency);
+    const packageName = packageInfo.name;
+    const dataPlatformAppNamespace = void 0 === packageName || '' === packageName ? 'unknown-app' : packageName;
+    const requestId = 'bundle' === options.target ? void 0 !== options.requestId && '' !== options.requestId.trim() ? options.requestId.trim() : void 0 !== packageName && '' !== packageName ? packageName : void 0 : void 0;
+    const normalizedRequestId = void 0 === requestId || '' === requestId ? 'default' : requestId;
+    const operationVersion = deriveOperationVersion(packageInfo.version);
+    const batchConfig = options.dataPlatformBatch;
+    const batchEndpoint = resolveBatchEndpoint(options.prefix, batchConfig?.endpoint);
+    const manifest = {
+        endpoints: endpoints.map((endpoint)=>({
+                apiId: endpoint.apiId,
+                group: endpoint.groupName,
+                endpoint: endpoint.endpointName,
+                method: endpoint.method,
+                routePath: endpoint.routePath,
+                schemaHash: createEffectEndpointContractHash(endpoint, normalizedRequestId),
+                operationVersion
+            }))
+    };
+    const config = {
+        appNamespace: dataPlatformAppNamespace,
+        ...void 0 !== requestId && '' !== requestId ? {
+            requestId
+        } : {},
+        port: options.port,
+        useEnvPort: 'server' === options.target,
+        defaultOrigin: `http://localhost:${String(options.port)}`,
+        httpMethodDecider,
+        batch: {
+            enabled: batchConfig?.enabled ?? true,
+            endpoint: batchEndpoint,
+            flushIntervalMs: batchConfig?.flushIntervalMs ?? 8,
+            maxBatchSize: batchConfig?.maxBatchSize ?? 16,
+            maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
+            requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
+            allowedMethods: batchConfig?.allowedMethods !== void 0 && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
+                'GET'
+            ]
+        }
+    };
+    return {
+        config,
+        manifest,
+        operationContracts: buildOperationContractMap({
+            handlers: toOperationContractSources(endpoints),
+            requestId: normalizedRequestId,
+            operationVersion
+        }),
+        operationVersion,
+        requestCreator,
+        requestId: normalizedRequestId
+    };
+}
+function renderClientShape(endpoints, valueType) {
+    if (0 === endpoints.length) return `Record<string, Record<string, ${valueType}>>`;
+    const groups = new Map();
+    for (const endpoint of endpoints){
+        const group = groups.get(endpoint.groupName) || [];
+        group.push(endpoint.endpointName);
+        groups.set(endpoint.groupName, group);
+    }
+    const groupEntries = [
+        ...groups.entries()
+    ].map(([groupName, names])=>{
+        const endpointEntries = names.map((name)=>`    ${JSON.stringify(name)}: ${valueType};`).join('\n');
+        return `  ${JSON.stringify(groupName)}: {\n${endpointEntries}\n  };`;
+    });
+    return `{\n${groupEntries.join('\n')}\n}`;
+}
+function renderEffectClientDeclaration(endpoints = []) {
+    return `export type EffectClientOperation = (
+  request?: unknown,
+) => Promise<unknown>;
+export type EffectClientGroup = Record<string, EffectClientOperation>;
+export type EffectClient = Record<string, EffectClientGroup>;
+export type EffectOperationDescriptor = {
+  appNamespace: string;
+  apiId: string;
+  group: string;
+  endpoint: string;
+  operationId: string;
+  routePath: string;
+  method: string;
+  operationVersion: number;
+  schemaHash: string;
+  version: number;
+};
+export type EffectOperationManifest = Record<
+  string,
+  Record<string, EffectOperationDescriptor>
+>;
+export type EffectOperationContext = {
+  requestId?: string;
+  operationId?: string;
+  routePath?: string;
+  method?: string;
+  schemaHash?: string;
+  operationVersion?: number;
+  locale?: string;
+  traceparent?: string;
+  traceId?: string;
+  spanId?: string;
+  source?: string;
+  scope?: Record<string, unknown>;
+  sessionClaims?: Record<string, unknown>;
+  attributes?: Record<string, unknown>;
+};
+export type EffectRequestContext = {
+  headers?: Record<string, string>;
+  locale?: string;
+  operationContext?: EffectOperationContext;
+  traceparent?: string;
+  traceId?: string;
+  spanId?: string;
+};
+export type GeneratedEffectClient = ${renderClientShape(endpoints, 'EffectClientOperation')};
+export type GeneratedEffectOperationManifest = ${renderClientShape(endpoints, "EffectOperationDescriptor")};
+
+export declare const client: GeneratedEffectClient;
+export declare const createEffectRequestContext: (
+  requestContext: Record<string, unknown>,
+) => EffectRequestContext;
+export declare const operationManifest: GeneratedEffectOperationManifest;
+declare const apiModule: {
+  client: GeneratedEffectClient;
+  createEffectRequestContext: typeof createEffectRequestContext;
+  operationManifest: GeneratedEffectOperationManifest;
+};
+
+export default apiModule;
+`;
+}
+export { createEffectClientGeneration, renderEffectClientCode, renderEffectClientDeclaration };

package/dist/esm-node/client-generator/runtime.mjs

@@ -0,0 +1,29 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { extractHttpApiFromModule } from "@modern-js/bff-effect/effect";
+import { compatibleRequire, upath } from "@modern-js/utils";
+import { loadEffectSourceModule } from "../effect-source-loader/loader.mjs";
+let httpApiRuntimePromise;
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+function isHttpApiRuntime(value) {
+    return isRecord(value) && 'function' == typeof value.isHttpApi && 'function' == typeof value.reflect;
+}
+function getHttpApiRuntime() {
+    if (void 0 === httpApiRuntimePromise) httpApiRuntimePromise = compatibleRequire('effect/unstable/httpapi', false).catch((error)=>{
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("Cannot find module 'effect/unstable/httpapi'")) throw error;
+        const effectPackageJson = require.resolve('effect/package.json');
+        const effectHttpApiRuntimePath = upath.join(upath.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
+        return compatibleRequire(effectHttpApiRuntimePath, false);
+    }).then((mod)=>{
+        if (isRecord(mod) && isHttpApiRuntime(mod.HttpApi)) return mod.HttpApi;
+        throw new Error('[BFF][Effect] Unable to resolve HttpApi runtime from effect/unstable/httpapi.');
+    });
+    return httpApiRuntimePromise;
+}
+function loadEffectApi(options) {
+    return getHttpApiRuntime().then((httpApiRuntime)=>loadEffectSourceModule(options).then((mod)=>extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi)));
+}
+export { getHttpApiRuntime, loadEffectApi };

package/dist/esm-node/client-generator/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/cross-project-generation/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { renderProducerRuntimeDefaults } from "./render.mjs";

package/dist/esm-node/cross-project-generation/render.mjs

@@ -0,0 +1,16 @@
+import "node:module";
+const renderProducerRuntimeDefaults = (requestIdValue)=>`{
+      requestId: ${requestIdValue},
+      requireEnvelope: true,
+      identityBinding: {
+        enabled: true,
+        strict: true,
+      },
+      operationContract: {
+        enabled: true,
+        strict: true,
+        requireSchemaHash: true,
+        requireOperationVersion: true,
+      },
+    }`;
+export { renderProducerRuntimeDefaults };

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

@@ -0,0 +1,35 @@
+import "node:module";
+import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/bff-core/security/cross-project-policy";
+const DENIAL_HEADERS = {
+    'content-type': 'application/json; charset=utf-8'
+};
+const checkCrossProjectPolicyResponse = (headers, policy, observedRequest)=>{
+    if (!policy?.enabled) return null;
+    const violation = evaluateCrossProjectPolicy(headers, policy, observedRequest);
+    if (!violation) return null;
+    return new Response(JSON.stringify({
+        code: violation.code,
+        reason: violation.reason,
+        message: violation.message
+    }), {
+        status: violation.status,
+        headers: DENIAL_HEADERS
+    });
+};
+const checkCrossProjectPolicyForRequest = (request, policy)=>{
+    if (!policy?.enabled) return null;
+    const requestTarget = {
+        method: request.method,
+        pathname: new URL(request.url).pathname
+    };
+    const observedRequest = resolveCrossProjectRequestObservation(requestTarget, policy) ?? {
+        method: requestTarget.method,
+        routePath: requestTarget.pathname
+    };
+    const headers = {};
+    request.headers.forEach((value, key)=>{
+        headers[key] = value;
+    });
+    return checkCrossProjectPolicyResponse(headers, policy, observedRequest);
+};
+export { checkCrossProjectPolicyForRequest, checkCrossProjectPolicyResponse };

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

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

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

@@ -0,0 +1,29 @@
+import "node:module";
+import { readFileSync } from "node:fs";
+import node_path from "node:path";
+import { deriveOperationVersion, resolveCrossProjectPolicy } from "@modern-js/bff-core";
+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)=>{
+    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))
+    });
+};
+export { resolveAdapterCrossProjectPolicy };

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

@@ -0,0 +1,27 @@
+import "node:module";
+import { collectEffectEndpoints, extractHttpApiFromModule, toOperationContractSources } from "@modern-js/bff-effect/effect";
+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) {
+    const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>extractHttpApiFromModule(mod, HttpApi.isHttpApi)).then((effectApi)=>{
+        if (null === effectApi) return [];
+        const reflect = (apiValue, handlers)=>{
+            if (!HttpApi.isHttpApi(apiValue)) throw new Error('[BFF][Effect] Endpoint reflection received a non-HttpApi value.');
+            HttpApi.reflect(apiValue, {
+                onGroup: handlers.onGroup ?? (()=>{}),
+                onEndpoint: handlers.onEndpoint
+            });
+        };
+        return toOperationContractSources(collectEffectEndpoints(reflect, effectApi, prefix));
+    }).catch((error)=>{
+        logger.warn(`[BFF][Effect] Failed reflect HttpApi endpoints cross-project policy: ${String(error)}`);
+        return [];
+    });
+    return contractSourcesPromise.then((contractSources)=>{
+        const policy = resolveAdapterCrossProjectPolicy(api, contractSources);
+        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 };

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

@@ -0,0 +1,51 @@
+import "node:module";
+import node_path from "node:path";
+import { API_DIR, findExists, fs, isProd } from "@modern-js/utils";
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+function resolveJsOrTsEntry(entryWithoutOrWithExt) {
+    const extension = node_path.extname(entryWithoutOrWithExt);
+    if (JS_OR_TS_EXTS.includes(extension)) return fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
+    return 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 = node_path.relative(appDirectory, entryPath);
+    return '..' === relativePath || relativePath.startsWith(`..${node_path.sep}`) ? void 0 : relativePath;
+}
+function isDependencyPath(relativePath) {
+    return relativePath?.split(/[\\/]/u).includes('node_modules') ?? false;
+}
+function resolveEffectAdapterEntryFile(api) {
+    const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
+    const appRoot = node_path.resolve(appDirectory || process.cwd());
+    const productionRoot = isProd() && distDirectory ? node_path.resolve(distDirectory) : void 0;
+    const configuredEntry = api.getServerConfig()?.bff?.effect?.entry;
+    if (configuredEntry) {
+        const sourceEntry = node_path.isAbsolute(configuredEntry) ? configuredEntry : node_path.resolve(appRoot, configuredEntry);
+        if (productionRoot) {
+            const relativeEntry = relativeAppPath(appRoot, sourceEntry);
+            if (void 0 === relativeEntry || isDependencyPath(relativeEntry)) return resolveJsOrTsEntry(sourceEntry);
+            return relativeEntry ? resolveJsOrTsEntry(builtEntryPath(node_path.resolve(productionRoot, relativeEntry))) : void 0;
+        }
+        return resolveJsOrTsEntry(sourceEntry);
+    }
+    const resolvedApiDirectory = node_path.resolve(appRoot, apiDirectory || API_DIR);
+    const productionApiDirectory = productionRoot ? void 0 !== relativeAppPath(productionRoot, resolvedApiDirectory) ? resolvedApiDirectory : (()=>{
+        const relativeApiDirectory = relativeAppPath(appRoot, resolvedApiDirectory);
+        if (isDependencyPath(relativeApiDirectory)) return resolvedApiDirectory;
+        return relativeApiDirectory ? node_path.resolve(productionRoot, relativeApiDirectory) : void 0;
+    })() : resolvedApiDirectory;
+    return productionApiDirectory ? resolveJsOrTsEntry(node_path.resolve(productionApiDirectory, 'index')) : void 0;
+}
+export { resolveEffectAdapterEntryFile };

package/dist/esm-node/effect-adapter/error-response.mjs

@@ -0,0 +1,38 @@
+import "node:module";
+import { createSafeFailureResponse } from "@modern-js/runtime-extensions/safe-failure";
+import { logger } from "@modern-js/utils";
+function createEffectAdapterRuntimeErrorResponse(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)=>{
+            logger.error(`Error in serverConfig.onError handler: ${String(configError)}`);
+            return createSafeFailureResponse(error);
+        });
+        logger.error(error instanceof Error ? error : new Error(String(error)));
+    } catch (configError) {
+        logger.error(`Error in serverConfig.onError handler: ${configError}`);
+    }
+    return Promise.resolve(createSafeFailureResponse(error));
+}
+function ensureJsonContext(context) {
+    if ('json' in context && 'function' == typeof context.json) return context;
+    return Object.assign({}, context, {
+        json (data, statusOrInit = 200, extraHeaders) {
+            const responseInit = 'number' == typeof statusOrInit ? {
+                status: statusOrInit,
+                headers: extraHeaders
+            } : statusOrInit;
+            const responseHeaders = new Headers({
+                'content-type': 'application/json; charset=utf-8'
+            });
+            if (void 0 !== responseInit.headers) new Headers(responseInit.headers).forEach((value, key)=>{
+                responseHeaders.set(key, value);
+            });
+            return new Response(JSON.stringify(data), {
+                ...responseInit,
+                headers: responseHeaders
+            });
+        }
+    });
+}
+export { createEffectAdapterRuntimeErrorResponse };