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

package/README.md

@@ -1,7 +1,7 @@
 # @modern-js/plugin-bff-extensions
 
 Fork-owned integration extensions for UltraModern.js BFFs. This package keeps
-Effect adapter lifecycle integration, source and client generation,
+Effect adapter lifecycle integration, server source loading,
 cross-project policy, Hono middleware, and backend federation out of the
 upstream-owned `@modern-js/plugin-bff` implementation.
 
@@ -12,8 +12,7 @@ upstream Modern.js project.
 ## Entry points
 
 - `/hono` exposes the peer-independent Hono route binder.
-- `/cross-project-policy`, `/effect-adapter`, `/effect-source-loader`, and
-  `/client-generator` expose Node tooling and server integration.
+- `/cross-project-policy`, `/effect-adapter`, and `/effect-source-loader` expose Node tooling and server integration.
 - `/cross-project-generation` renders the generated producer client runtime
   consumed by `@modern-js/plugin-bff`.
 - `/backend-federation` exposes the portable federation runtime, while
@@ -27,3 +26,7 @@ Effect and its OpenTelemetry integration are exact-cohort optional peers. A
 Hono-only consumer can import `/hono` without installing Effect.
 
 There is deliberately no adapter-kit or re-export-only compatibility layer.
+
+Effect server tooling derives operation-contract metadata without generating
+client code. Import shared `HttpApi` contracts in clients and use native
+`HttpApiClient.make`; the former `/client-generator` entry point is removed.

package/dist/cjs/backend-federation/edge-runtime.js

@@ -29,8 +29,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createBackendFederationLoadEntryPlugin: ()=>createBackendFederationLoadEntryPlugin,
-    createBackendFederationRuntime: ()=>createBackendFederationRuntime,
-    createBackendFederationRuntimeForLoad: ()=>createBackendFederationRuntimeForLoad
+    createBackendFederationRuntime: ()=>createBackendFederationRuntime
 });
 const external_validate_loaded_js_namespaceObject = require("./validate-loaded.js");
 function _check_private_redeclaration(obj, privateCollection) {
@@ -100,7 +99,7 @@ async function resolveEdgeEntry(plugins, remote) {
     }
     throw new Error(`[BFF][Effect] Missing static or service-binding entry provider for backend federation remote ${remote.name}.`);
 }
-var _entries = /*#__PURE__*/ new WeakMap(), _expected = /*#__PURE__*/ new WeakMap(), _hostName = /*#__PURE__*/ new WeakMap(), _allowMissingIdentityMetadata = /*#__PURE__*/ new WeakMap(), _modules = /*#__PURE__*/ new WeakMap(), _plugins = /*#__PURE__*/ new WeakMap(), _remotes = /*#__PURE__*/ new WeakMap(), _loadEntry = /*#__PURE__*/ new WeakSet(), _loadModule = /*#__PURE__*/ new WeakSet();
+var _entries = /*#__PURE__*/ new WeakMap(), _expected = /*#__PURE__*/ new WeakMap(), _hostName = /*#__PURE__*/ new WeakMap(), _modules = /*#__PURE__*/ new WeakMap(), _plugins = /*#__PURE__*/ new WeakMap(), _remotes = /*#__PURE__*/ new WeakMap(), _loadEntry = /*#__PURE__*/ new WeakSet(), _loadModule = /*#__PURE__*/ new WeakSet();
 class EdgeBackendFederationRuntime {
     async loadRemote(request) {
         const existing = _class_private_field_get(this, _modules).get(request);
@@ -127,10 +126,6 @@ class EdgeBackendFederationRuntime {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _allowMissingIdentityMetadata, {
-            writable: true,
-            value: void 0
-        });
         _class_private_field_init(this, _modules, {
             writable: true,
             value: void 0
@@ -146,7 +141,6 @@ class EdgeBackendFederationRuntime {
         _class_private_field_set(this, _entries, new Map());
         _class_private_field_set(this, _modules, new Map());
         if (void 0 !== options.entryPolicy) throw new Error('[BFF][Effect] Edge backend federation does not execute entry evaluators. Register a static or service-binding entry provider.');
-        _class_private_field_set(this, _allowMissingIdentityMetadata, true === options.allowMissingIdentityMetadata);
         _class_private_field_set(this, _expected, options.expected);
         _class_private_field_set(this, _hostName, options.hostName);
         _class_private_field_set(this, _plugins, options.plugins ?? []);
@@ -185,7 +179,6 @@ function loadModule(request) {
         if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${expose.replace(/^\.\//u, '')} must load factory function.`);
         const loaded = await factory();
         return (0, external_validate_loaded_js_namespaceObject.validateLoadedBackendFederatedEffectApi)(loaded, {
-            allowMissingIdentityMetadata: _class_private_field_get(this, _allowMissingIdentityMetadata),
             expected: _class_private_field_get(this, _expected),
             remoteName,
             remoteRequest: request
@@ -214,16 +207,11 @@ function createBackendFederationRuntime(options) {
     if (void 0 === options.expected || 'string' != typeof options.expected.unitId || 0 === options.expected.unitId.length || 'string' != typeof options.expected.buildMarker || 0 === options.expected.buildMarker.length) throw new Error('[BFF][Effect] Edge backend federation runtime requires expected.unitId and expected.buildMarker.');
     return new EdgeBackendFederationRuntime(options);
 }
-function createBackendFederationRuntimeForLoad(options) {
-    return new EdgeBackendFederationRuntime(options);
-}
 exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
 exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
-exports.createBackendFederationRuntimeForLoad = __webpack_exports__.createBackendFederationRuntimeForLoad;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createBackendFederationLoadEntryPlugin",
-    "createBackendFederationRuntime",
-    "createBackendFederationRuntimeForLoad"
+    "createBackendFederationRuntime"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -39,19 +39,18 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const external_edge_runtime_js_namespaceObject = require("./edge-runtime.js");
-const external_legacy_warning_js_namespaceObject = require("./legacy-warning.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const external_identity_js_namespaceObject = require("./identity.js");
 function loadBackendFederatedEffectApi(options) {
     if (void 0 !== options.runtime || void 0 !== options.entryPolicy) return Promise.reject(new Error('[BFF][Effect] Edge backend federation does not execute custom runtimes or entry evaluators. Register a static or service-binding entry provider.'));
     const remoteName = options.remote?.name ?? options.remoteName;
     if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
-    if (void 0 === options.expected) console.warn(external_legacy_warning_js_namespaceObject.LEGACY_LOAD_WARNING);
+    if (!options.expected?.unitId || !options.expected.buildMarker) return Promise.reject(new Error('[BFF][Effect] Backend federation requires expected.unitId and expected.buildMarker.'));
     const expose = options.expose ?? options.remote?.expose ?? backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
     const remoteRequest = `${remoteName}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)}`;
     let runtime;
     try {
-        runtime = (0, external_edge_runtime_js_namespaceObject.createBackendFederationRuntimeForLoad)(options);
+        runtime = (0, external_edge_runtime_js_namespaceObject.createBackendFederationRuntime)(options);
     } catch (error) {
         return Promise.reject(error);
     }

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

@@ -32,37 +32,31 @@ __webpack_require__.d(__webpack_exports__, {
     validateExpectedBackendFederationIdentity: ()=>validateExpectedBackendFederationIdentity
 });
 const external_utils_js_namespaceObject = require("./utils.js");
-function validateExpectedBackendFederationIdentity(loaded, expected, options = {}) {
-    const allowMissing = true === options.allowMissingIdentityMetadata;
+function validateExpectedBackendFederationIdentity(loaded, expected) {
     const issues = [];
     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)) {
-        if (allowMissing) return [];
-        return [
-            {
-                path: 'backendFederationContract.compatibility',
-                message: 'loaded module declares no compatibility metadata; delivery-unit identity cannot be validated'
-            }
-        ];
-    }
+    if (!(0, external_utils_js_namespaceObject.isRecord)(compatibility)) return [
+        {
+            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) {
-        if (!allowMissing) issues.push({
-            path: 'backendFederationContract.compatibility.unitId',
-            message: `missing delivery-unit id; expected ${expected.unitId}`
-        });
-    } else if (unitId !== expected.unitId) issues.push({
+    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) {
-        if (!allowMissing) issues.push({
-            path: 'backendFederationContract.compatibility.build',
-            message: `missing build marker; expected ${expected.buildMarker}`
-        });
-    } else if (build !== expected.buildMarker) issues.push({
+    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}`
     });

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

@@ -31,23 +31,14 @@ __webpack_require__.d(__webpack_exports__, {
     loadBackendFederatedEffectApi: ()=>loadBackendFederatedEffectApi
 });
 const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
-const Effect_namespaceObject = require("effect/Effect");
-const Logger_namespaceObject = require("effect/Logger");
-const external_legacy_warning_js_namespaceObject = require("./legacy-warning.js");
 const external_remotes_js_namespaceObject = require("./remotes.js");
 const external_runtime_js_namespaceObject = require("./runtime.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const external_validate_loaded_js_namespaceObject = require("./validate-loaded.js");
-const legacyWarningLogger = Logger_namespaceObject.withLeveledConsole(Logger_namespaceObject.formatLogFmt);
-function warnLegacyLoad() {
-    Effect_namespaceObject.runSync(Effect_namespaceObject.provideService(Effect_namespaceObject.logWarning(external_legacy_warning_js_namespaceObject.LEGACY_LOAD_WARNING), Logger_namespaceObject.CurrentLoggers, new Set([
-        legacyWarningLogger
-    ])));
-}
 function loadBackendFederatedEffectApi(options) {
     const remoteName = options.remote?.name ?? options.remoteName;
     if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
-    if (void 0 === options.expected) warnLegacyLoad();
+    if (!options.expected?.unitId || !options.expected.buildMarker) return Promise.reject(new Error('[BFF][Effect] Backend federation requires expected.unitId and expected.buildMarker.'));
     if (void 0 !== options.runtime) {
         const configuredRemote = (0, external_remotes_js_namespaceObject.collectRemotes)(options).find((remote)=>remote.name === remoteName);
         if (void 0 === configuredRemote || !/^(?:binding|service|static):/u.test(configuredRemote.entry)) return Promise.reject(new Error('[BFF][Effect] A custom Module Federation runtime requires a caller-pinned static or service-binding remote and cannot execute network backend federation entries.'));
@@ -57,7 +48,6 @@ function loadBackendFederatedEffectApi(options) {
     const expose = options.expose ?? options.remote?.expose ?? backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
     const remoteRequest = `${remoteName}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)}`;
     return runtime.loadRemote(remoteRequest).then((loaded)=>(0, external_validate_loaded_js_namespaceObject.validateLoadedBackendFederatedEffectApi)(loaded, {
-            allowMissingIdentityMetadata: options.allowMissingIdentityMetadata,
             expected: options.expected,
             remoteName,
             remoteRequest

package/dist/cjs/backend-federation/validate-loaded.js

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

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

@@ -33,6 +33,7 @@ __webpack_require__.d(__webpack_exports__, {
 const index_js_namespaceObject = require("../backend-federation/index.js");
 const load_js_namespaceObject = require("../backend-federation/load.js");
 const external_errors_js_namespaceObject = require("./errors.js");
+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");
@@ -127,6 +128,10 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
         if (remoteManifest && /^https?:\/\//iu.test(remote.entry) && !hasPinnedRemoteEntryExpectation(options)) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} from a network manifest requires caller-pinned entryUrl, remoteName, sha256, and byteLength values.`);
         if (/^https?:\/\//iu.test(remote.entry) && void 0 === remote.verification && options.entryPolicy?.expected === void 0) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} requires entry.sha256 and entry.byteLength before network execution.`);
         if (/^https?:\/\//iu.test(remote.entry) && void 0 !== options.runtime) throw new external_errors_js_namespaceObject.BackendFederationManifestAdapterError('manifest_invalid', `[BFF][Effect] Backend federation remote ${remote.name} cannot use a custom runtime for network entry execution.`);
+        const deliveryUnit = (0, external_metadata_js_namespaceObject.manifestDeliveryUnit)((0, external_metadata_js_namespaceObject.backendFederationMetadata)(manifest), (0, external_metadata_js_namespaceObject.versionBoundaryMetadata)(manifest));
+        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)({
             hostName: options.hostName,
             remote,
@@ -141,13 +146,10 @@ async function loadBackendFederatedEffectApiFromManifest(options) {
             ...options.runtime ? {
                 runtime: options.runtime
             } : {},
-            ...options.expected?.unitId && options.expected.buildMarker ? {
-                expected: {
-                    unitId: options.expected.unitId,
-                    buildMarker: options.expected.buildMarker
-                },
-                allowMissingIdentityMetadata: true
-            } : {}
+            expected: {
+                unitId,
+                buildMarker
+            }
         }).catch((error)=>{
             throw new 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);
         });

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

@@ -50,8 +50,7 @@ function validateBackendFederationManifest(manifest, expected = {}) {
     (0, external_errors_js_namespaceObject.assertManifestAdapter)(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
     const manifestShape = (0, backend_federation_contracts_namespaceObject.validateBackendFederationManifest)(manifest, {
         expectedContractVersion: false,
-        expectedNodeAdapterVersion: false,
-        validateDeliveryUnit: false
+        expectedNodeAdapterVersion: false
     });
     (0, external_errors_js_namespaceObject.assertManifestAdapter)(manifestShape.ok, 'manifest_invalid', `[BFF][Effect] Backend federation manifest schema invalid: ${(0, backend_federation_contracts_namespaceObject.formatBackendFederationValidationErrors)(manifestShape.errors)}.`);
     (0, external_errors_js_namespaceObject.assertManifestAdapter)('effect' === backendFederation.runtimeFramework, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare runtimeFramework: "effect".');
@@ -69,6 +68,7 @@ function validateBackendFederationManifest(manifest, expected = {}) {
     (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), (0, external_metadata_js_namespaceObject.stringValue)(boundary?.buildVersion), 'versionBoundary.deliveryUnit.buildMarker vs versionBoundary.buildVersion');
     (0, external_errors_js_namespaceObject.assertConsistentValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId), (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId), 'backendFederation.deliveryUnit.unitId vs versionBoundary.deliveryUnit.unitId');
     const manifestUnitId = (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.unitId) ?? (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.top?.unitId);
+    (0, external_errors_js_namespaceObject.assertManifestAdapter)(manifestUnitId && (0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), 'manifest_invalid', 'Backend federation manifest requires delivery-unit unitId and buildMarker.');
     (0, external_errors_js_namespaceObject.assertVersionValue)(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
     (0, external_errors_js_namespaceObject.assertVersionValue)((0, external_metadata_js_namespaceObject.stringValue)(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
 }
@@ -87,8 +87,8 @@ function validateLoadedBackendFederationContract(loaded, manifest, remote) {
     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.assertConsistentValue)(manifestUnitId, (0, external_metadata_js_namespaceObject.stringValue)(compatibility.unitId), 'deliveryUnit.unitId vs expose compatibility.unitId');
-    (0, external_errors_js_namespaceObject.assertConsistentValue)(manifestBuildMarker, (0, external_metadata_js_namespaceObject.stringValue)(compatibility.build), 'deliveryUnit.buildMarker vs expose compatibility.build');
+    (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');
 }
 function classifyLoadError(error) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/cjs/{client-generator → effect-source-loader}/built-entry.js

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

package/dist/cjs/{client-generator/runtime.js → effect-source-loader/http-api-runtime.js}

@@ -32,30 +32,22 @@ __webpack_require__.d(__webpack_exports__, {
     loadEffectApi: ()=>loadEffectApi
 });
 const effect_namespaceObject = require("@modern-js/bff-effect/effect");
-const utils_namespaceObject = require("@modern-js/utils");
-const loader_js_namespaceObject = require("../effect-source-loader/loader.js");
-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;
-}
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const external_loader_js_namespaceObject = require("./loader.js");
 function getHttpApiRuntime() {
-    if (void 0 === httpApiRuntimePromise) httpApiRuntimePromise = (0, utils_namespaceObject.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 = utils_namespaceObject.upath.join(utils_namespaceObject.upath.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
-        return (0, utils_namespaceObject.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 Promise.resolve({
+        isHttpApi: httpapi_namespaceObject.HttpApi.isHttpApi,
+        reflect: (api, handlers)=>{
+            if (!httpapi_namespaceObject.HttpApi.isHttpApi(api)) throw new TypeError('[BFF][Effect] Expected an HttpApi contract.');
+            httpapi_namespaceObject.HttpApi.reflect(api, {
+                onGroup: handlers.onGroup ?? (()=>{}),
+                onEndpoint: handlers.onEndpoint
+            });
+        }
     });
-    return httpApiRuntimePromise;
 }
 function loadEffectApi(options) {
-    return getHttpApiRuntime().then((httpApiRuntime)=>(0, loader_js_namespaceObject.loadEffectSourceModule)(options).then((mod)=>(0, effect_namespaceObject.extractHttpApiFromModule)(mod, httpApiRuntime.isHttpApi)));
+    return getHttpApiRuntime().then((httpApiRuntime)=>(0, external_loader_js_namespaceObject.loadEffectSourceModule)(options).then((mod)=>(0, effect_namespaceObject.extractHttpApiFromModule)(mod, httpApiRuntime.isHttpApi)));
 }
 exports.getHttpApiRuntime = __webpack_exports__.getHttpApiRuntime;
 exports.loadEffectApi = __webpack_exports__.loadEffectApi;

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

@@ -28,27 +28,35 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    bundleBuiltEffectEntryForNode: ()=>external_built_entry_js_namespaceObject.bundleBuiltEffectEntryForNode,
     bundleEffectEntryForNode: ()=>external_loader_js_namespaceObject.bundleEffectEntryForNode,
     bundleEffectWorkerRuntimeSource: ()=>external_worker_runtime_source_js_namespaceObject.bundleEffectWorkerRuntimeSource,
-    generateEffectClientCode: ()=>external_worker_runtime_wrapper_js_namespaceObject.generateEffectClientCode,
     generateEffectWorkerRuntimeWrapper: ()=>external_worker_runtime_wrapper_js_namespaceObject.generateEffectWorkerRuntimeWrapper,
-    resolveEffectEntryFile: ()=>paths_js_namespaceObject.resolveEffectEntryFile
+    resolveEffectEntryFile: ()=>external_paths_js_namespaceObject.resolveEffectEntryFile,
+    resolveEffectEntryPaths: ()=>external_built_entry_js_namespaceObject.resolveEffectEntryPaths,
+    resolveEffectOperationContracts: ()=>external_operation_contracts_js_namespaceObject.resolveEffectOperationContracts
 });
-const paths_js_namespaceObject = require("../client-generator/paths.js");
+const external_built_entry_js_namespaceObject = require("./built-entry.js");
 const external_loader_js_namespaceObject = require("./loader.js");
+const external_operation_contracts_js_namespaceObject = require("./operation-contracts.js");
+const external_paths_js_namespaceObject = require("./paths.js");
 const external_worker_runtime_source_js_namespaceObject = require("./worker-runtime-source.js");
 const external_worker_runtime_wrapper_js_namespaceObject = require("./worker-runtime-wrapper.js");
+exports.bundleBuiltEffectEntryForNode = __webpack_exports__.bundleBuiltEffectEntryForNode;
 exports.bundleEffectEntryForNode = __webpack_exports__.bundleEffectEntryForNode;
 exports.bundleEffectWorkerRuntimeSource = __webpack_exports__.bundleEffectWorkerRuntimeSource;
-exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
 exports.generateEffectWorkerRuntimeWrapper = __webpack_exports__.generateEffectWorkerRuntimeWrapper;
 exports.resolveEffectEntryFile = __webpack_exports__.resolveEffectEntryFile;
+exports.resolveEffectEntryPaths = __webpack_exports__.resolveEffectEntryPaths;
+exports.resolveEffectOperationContracts = __webpack_exports__.resolveEffectOperationContracts;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bundleBuiltEffectEntryForNode",
     "bundleEffectEntryForNode",
     "bundleEffectWorkerRuntimeSource",
-    "generateEffectClientCode",
     "generateEffectWorkerRuntimeWrapper",
-    "resolveEffectEntryFile"
+    "resolveEffectEntryFile",
+    "resolveEffectEntryPaths",
+    "resolveEffectOperationContracts"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -0,0 +1,83 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveEffectOperationContracts: ()=>resolveEffectOperationContracts
+});
+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)
+    });
+}
+exports.resolveEffectOperationContracts = __webpack_exports__.resolveEffectOperationContracts;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveEffectOperationContracts"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -59,23 +59,7 @@ async function loader(source) {
             });
             callback(void 0, await (0, external_index_js_namespaceObject.bundleEffectWorkerRuntimeSource)(transformed.code, this.resourcePath, this));
         } else if (query.has('modern-bff-runtime')) callback(void 0, await (0, external_index_js_namespaceObject.generateEffectWorkerRuntimeWrapper)(this, options, this.resourcePath));
-        else {
-            const code = await (0, external_index_js_namespaceObject.generateEffectClientCode)({
-                appDir: options.appDir,
-                apiDir: options.apiDir,
-                resourcePath: this.resourcePath,
-                prefix: options.prefix,
-                port: Number(options.port),
-                target: options.target,
-                requestId: options.requestId,
-                requestCreator: options.requestCreator,
-                httpMethodDecider: options.httpMethodDecider,
-                dataPlatformBatch: options.effectDataPlatformBatch,
-                onDependency: (dependency)=>this.addDependency(dependency)
-            });
-            if (null === code) throw new Error(`Failed to generate Effect client for ${this.resourcePath}`);
-            callback(void 0, code);
-        }
+        else throw new Error('Effect BFF entries are server-only. Import the shared HttpApi contract and use HttpApiClient.make (or makeEffectHttpApiClient) for a fully inferred client.');
     } catch (error) {
         callback(error instanceof Error ? error : new Error(String(error)));
     }

package/dist/cjs/effect-source-loader/worker-runtime-wrapper.js

@@ -27,41 +27,26 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    generateEffectWorkerRuntimeWrapper: ()=>generateEffectWorkerRuntimeWrapper
+});
+const external_operation_contracts_js_namespaceObject = require("./operation-contracts.js");
 async function generateEffectWorkerRuntimeWrapper(loader, options, resourcePath) {
-    const { generateEffectClient } = await import("../client-generator/generator.js");
-    const artifacts = await generateEffectClient({
+    const operationContracts = await (0, external_operation_contracts_js_namespaceObject.resolveEffectOperationContracts)({
         appDir: options.appDir,
-        apiDir: options.apiDir,
         resourcePath,
         prefix: options.prefix,
-        port: Number(options.port),
-        target: 'bundle',
         requestId: options.requestId,
-        requestCreator: options.requestCreator,
-        httpMethodDecider: options.httpMethodDecider,
-        dataPlatformBatch: options.effectDataPlatformBatch,
         onDependency: (dependency)=>loader.addDependency(dependency)
     });
     const sourceRequest = `${resourcePath}?modern-bff-runtime-source`;
-    const operationContracts = artifacts?.operationContracts ?? {};
     return `import * as effectBffModule from ${JSON.stringify(sourceRequest)};
 import { createEffectBffEdgeDispatcherFactory } from '@modern-js/bff-effect/effect-edge';
-export const __modern_create_effect_bff_dispatcher = createEffectBffEdgeDispatcherFactory(effectBffModule, ${JSON.stringify(operationContracts)});
+export const __modern_create_effect_bff_dispatcher = createEffectBffEdgeDispatcherFactory(effectBffModule, ${JSON.stringify(operationContracts ?? {})});
 `;
 }
-async function generateEffectClientCode(options) {
-    const { generateEffectClient } = await import("../client-generator/generator.js");
-    const artifacts = await generateEffectClient(options);
-    return null === artifacts ? null : artifacts.code;
-}
-__webpack_require__.d(__webpack_exports__, {
-    generateEffectClientCode: ()=>generateEffectClientCode,
-    generateEffectWorkerRuntimeWrapper: ()=>generateEffectWorkerRuntimeWrapper
-});
-exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
 exports.generateEffectWorkerRuntimeWrapper = __webpack_exports__.generateEffectWorkerRuntimeWrapper;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "generateEffectClientCode",
     "generateEffectWorkerRuntimeWrapper"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

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

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

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