@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.98 → 3.8.1-ultramodern.1

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

@@ -1,7 +1,6 @@
 import "node:module";
 import { deriveOperationVersion } from "@modern-js/bff-core";
-import { fs } from "@modern-js/utils";
-import path from "path";
+import { fs, upath } from "@modern-js/utils";
 import { createEffectEndpointContractHash, ensureLeadingSlash, normalizeEffectPrefix } from "../../runtime/effect/endpoint-contracts.mjs";
 const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
 const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
@@ -14,17 +13,17 @@ function isAbsoluteUrl(value) {
     }
 }
 function resolveBatchEndpoint(prefix, endpoint) {
-    const value = endpoint || '/_data/batch';
+    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 ('' === normalizedPrefix) return normalizedEndpoint;
     if (normalizedEndpoint === normalizedPrefix || normalizedEndpoint.startsWith(`${normalizedPrefix}/`)) return normalizedEndpoint;
     return `${normalizedPrefix}${'/' === normalizedEndpoint ? '' : normalizedEndpoint}`;
 }
 function getPackageInfo(appDir) {
     try {
-        const packageJsonPath = path.resolve(appDir, './package.json');
+        const packageJsonPath = upath.resolve(appDir, './package.json');
         const packageJson = fs.readJSONSync(packageJsonPath);
         return {
             name: packageJson.name,
@@ -39,9 +38,9 @@ function renderEffectClientCode(endpoints, options) {
     const httpMethodDecider = options.httpMethodDecider || 'functionName';
     const packageInfo = getPackageInfo(options.appDir);
     const packageName = packageInfo.name;
-    const dataPlatformAppNamespace = packageName || 'unknown-app';
-    const requestId = 'bundle' === options.target ? packageName || process.env.npm_package_name : void 0;
-    const normalizedRequestId = requestId || 'default';
+    const dataPlatformAppNamespace = void 0 === packageName || '' === packageName ? 'unknown-app' : packageName;
+    const requestId = 'bundle' === options.target ? 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);
@@ -58,7 +57,7 @@ function renderEffectClientCode(endpoints, options) {
     };
     const config = {
         appNamespace: dataPlatformAppNamespace,
-        ...requestId ? {
+        ...void 0 !== requestId && '' !== requestId ? {
             requestId
         } : {},
         port: options.port,
@@ -72,7 +71,7 @@ function renderEffectClientCode(endpoints, options) {
             maxBatchSize: batchConfig?.maxBatchSize ?? 16,
             maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
             requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
-            allowedMethods: batchConfig?.allowedMethods && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
+            allowedMethods: batchConfig?.allowedMethods !== void 0 && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
                 'GET'
             ]
         }

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

@@ -1,36 +1,29 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { compatibleRequire } from "@modern-js/utils";
-import path from "path";
+import { compatibleRequire, upath } from "@modern-js/utils";
 import { extractHttpApiFromModule } from "../../runtime/effect/endpoint-contracts.mjs";
 import { loadEffectSourceModule } from "../effectSourceLoader.mjs";
 let httpApiRuntimePromise;
 function isRecord(value) {
     return 'object' == typeof value && null !== value;
 }
-async function getHttpApiRuntime() {
-    if (!httpApiRuntimePromise) httpApiRuntimePromise = (async ()=>{
-        let mod;
-        try {
-            mod = await 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 = path.join(path.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
-            mod = await compatibleRequire(effectHttpApiRuntimePath, false);
-        }
-        if (isRecord(mod) && isRecord(mod.HttpApi)) {
-            const maybeHttpApi = mod.HttpApi;
-            if ('function' == typeof maybeHttpApi.isHttpApi && 'function' == typeof maybeHttpApi.reflect) return maybeHttpApi;
-        }
+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;
 }
-async function loadEffectApi(options) {
-    const httpApiRuntime = await getHttpApiRuntime();
-    const mod = await loadEffectSourceModule(options);
-    return extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi);
+function loadEffectApi(options) {
+    return getHttpApiRuntime().then((httpApiRuntime)=>loadEffectSourceModule(options).then((mod)=>extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi)));
 }
 export { getHttpApiRuntime, loadEffectApi };

package/dist/esm-node/utils/effectSourceLoader.mjs

@@ -1,7 +1,7 @@
 import "node:module";
 import node_crypto from "node:crypto";
 import node_fs from "node:fs";
-import { builtinModules } from "node:module";
+import { builtinModules, createRequire } from "node:module";
 import node_path from "node:path";
 import { pathToFileURL } from "node:url";
 import { build, transform } from "esbuild";
@@ -76,10 +76,29 @@ const nodeBuiltins = new Set([
     ...builtinModules.map((name)=>`node:${name}`)
 ]);
 const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+async function isEsmOnlyFile(filename) {
+    const extension = node_path.extname(filename).toLowerCase();
+    if ('.mjs' === extension || '.mts' === extension) return true;
+    if ('.cjs' === extension || '.cts' === extension) return false;
+    let directory = node_path.dirname(filename);
+    while(true){
+        const packagePath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = JSON.parse(await node_fs.promises.readFile(packagePath, 'utf8'));
+            return 'module' === packageJson.type;
+        } catch (error) {
+            if (!error || 'object' != typeof error || !('code' in error) || 'ENOENT' !== error.code) throw error;
+        }
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return false;
+        directory = parent;
+    }
+}
 function isBareSpecifier(specifier) {
     return !specifier.startsWith('.') && !specifier.startsWith('/') && !node_path.isAbsolute(specifier);
 }
-function externalizeInstalledDependencies() {
+function externalizeInstalledDependencies(options) {
+    const runtimeRequire = createRequire(node_path.join(options.runtimeResolveDir, '__modern_effect_entry.cjs'));
     return {
         name: 'modern-js-effect-installed-dependencies',
         setup (buildApi) {
@@ -109,19 +128,46 @@ function externalizeInstalledDependencies() {
                     path: args.path
                 };
                 const realPath = await node_fs.promises.realpath(resolution.path).catch(()=>resolution.path);
-                if (realPath.includes(`${node_path.sep}node_modules${node_path.sep}`)) return {
-                    external: true,
-                    path: args.path
-                };
+                if (realPath.includes(`${node_path.sep}node_modules${node_path.sep}`)) {
+                    const runtimeResolution = await buildApi.resolve(args.path, {
+                        importer: '',
+                        kind: args.kind,
+                        namespace: 'file',
+                        pluginData: {
+                            [dependencyResolutionMarker]: true
+                        },
+                        resolveDir: options.runtimeResolveDir
+                    });
+                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) {
+                        if ('cjs' === options.format) {
+                            let requiredPath;
+                            try {
+                                requiredPath = runtimeRequire.resolve(args.path);
+                            } catch  {
+                                requiredPath = runtimeResolution.path;
+                            }
+                            if (await isEsmOnlyFile(requiredPath)) return {
+                                namespace: resolution.namespace,
+                                path: resolution.path,
+                                pluginData: resolution.pluginData,
+                                sideEffects: resolution.sideEffects,
+                                suffix: resolution.suffix,
+                                warnings: resolution.warnings
+                            };
+                        }
+                        return {
+                            external: true,
+                            path: args.path
+                        };
+                    }
+                }
                 return {
                     namespace: resolution.namespace,
                     path: resolution.path,
                     pluginData: resolution.pluginData,
                     sideEffects: resolution.sideEffects,
                     suffix: resolution.suffix,
-                    warnings: resolution.warnings,
-                    watchDirs: resolution.watchDirs,
-                    watchFiles: resolution.watchFiles
+                    warnings: resolution.warnings
                 };
             });
         }
@@ -140,7 +186,10 @@ async function bundleEffectEntryForNode(options) {
         outfile: options.entryPath,
         platform: 'node',
         plugins: [
-            externalizeInstalledDependencies(),
+            externalizeInstalledDependencies({
+                format: options.format,
+                runtimeResolveDir: options.appDir
+            }),
             preserveSourceModuleSemantics()
         ],
         target: 'node20'
@@ -156,6 +205,11 @@ function normalizeImportedModule(module) {
     if (1 === Object.keys(namespace).length && null !== commonJsModule && 'object' == typeof commonJsModule && true === commonJsModule.__esModule) return commonJsModule;
     return module;
 }
+async function loadEffectBuiltModule(resourcePath) {
+    const canonicalPath = await node_fs.promises.realpath(node_path.resolve(resourcePath));
+    if (!await isEsmOnlyFile(canonicalPath)) return createRequire(canonicalPath)(canonicalPath);
+    return normalizeImportedModule(await dynamicImport(pathToFileURL(canonicalPath).href));
+}
 async function loadEffectSourceModule(options) {
     const resourcePath = node_path.resolve(options.resourcePath);
     const appDir = node_path.resolve(options.appDir ?? node_path.dirname(resourcePath));
@@ -182,7 +236,10 @@ async function loadEffectSourceModule(options) {
         outfile: outputPath,
         platform: 'node',
         plugins: [
-            externalizeInstalledDependencies(),
+            externalizeInstalledDependencies({
+                format: 'esm',
+                runtimeResolveDir: appDir
+            }),
             preserveSourceModuleSemantics()
         ],
         sourcemap: 'inline',
@@ -197,4 +254,4 @@ async function loadEffectSourceModule(options) {
     const revision = node_crypto.createHash('sha256').update(output).digest('hex');
     return normalizeImportedModule(await dynamicImport(`${pathToFileURL(outputPath).href}?v=${revision}`));
 }
-export { bundleEffectEntryForNode, loadEffectSourceModule };
+export { bundleEffectEntryForNode, loadEffectBuiltModule, loadEffectSourceModule };

package/dist/esm-node/utils/pluginGenerator.mjs

@@ -1,22 +1,22 @@
 import "node:module";
 import { fs, logger, normalizeToPosixPath } from "@modern-js/utils";
 import path from "path";
-import { API_DIR, DIST_DIR, LAMBDA_DIR, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK } from "./crossProjectApiPlugin.mjs";
+import { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK } from "./crossProjectApiPlugin.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-function replaceContent(source, packageName, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework) {
-    const updatedSource = source.replace(new RegExp(PACKAGE_NAME, 'g'), packageName).replace(new RegExp(PREFIX, 'g'), prefix).replace(new RegExp(DIST_DIR, 'g'), normalizeToPosixPath(relativeDistPath)).replace(new RegExp(API_DIR, 'g'), normalizeToPosixPath(relativeApiPath)).replace(new RegExp(LAMBDA_DIR, 'g'), normalizeToPosixPath(relativeLambdaPath)).replace(new RegExp(RUNTIME_FRAMEWORK, 'g'), runtimeFramework);
+function replaceContent(source, packageName, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts) {
+    const updatedSource = source.replace(new RegExp(PACKAGE_NAME, 'g'), packageName).replace(new RegExp(PREFIX, 'g'), prefix).replace(new RegExp(DIST_DIR, 'g'), normalizeToPosixPath(relativeDistPath)).replace(new RegExp(API_DIR, 'g'), normalizeToPosixPath(relativeApiPath)).replace(new RegExp(LAMBDA_DIR, 'g'), normalizeToPosixPath(relativeLambdaPath)).replace(new RegExp(RUNTIME_FRAMEWORK, 'g'), runtimeFramework).replace(new RegExp(EFFECT_ENTRY, 'g'), normalizeToPosixPath(relativeEffectEntry)).replace(`'${OPERATION_CONTRACTS_JSON}'`, ()=>JSON.stringify(JSON.stringify(operationContracts)));
     return updatedSource;
 }
-async function pluginGenerator({ prefix, appDirectory, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework }) {
+async function pluginGenerator({ prefix, appDirectory, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts }) {
     try {
         const packageContent = await fs.readFile(path.resolve(appDirectory, './package.json'), 'utf8');
         const packageJson = JSON.parse(packageContent);
         const pluginDir = path.resolve(appDirectory, `./${relativeDistPath}`, 'plugin');
         const pluginPath = path.join(pluginDir, 'index.js');
         const pluginTemplate = await fs.readFile(path.resolve(__rspack_import_meta_dirname__, 'crossProjectApiPlugin.js'), 'utf8');
-        const updatedPlugin = replaceContent(pluginTemplate, packageJson.name, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework);
+        const updatedPlugin = replaceContent(pluginTemplate, packageJson.name, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts);
         await fs.ensureFile(pluginPath);
         await fs.writeFile(pluginPath, updatedPlugin);
         const typeContent = `import type { AppTools, CliPlugin } from '@modern-js/app-tools';

package/dist/types/cli/generator.d.ts

@@ -1,7 +1,7 @@
 import type { AppTools } from '@modern-js/app-tools';
 import type { CLIPluginAPI } from '@modern-js/plugin';
 export declare const createBffGenerator: (api: CLIPluginAPI<AppTools>) => {
-    compileApi: () => Promise<void>;
+    compileApi: () => Promise<void | undefined>;
     generate: () => Promise<void>;
-    handleCrossProjectInvocation: (isBuild?: boolean) => Promise<void>;
+    handleCrossProjectInvocation: (isBuild?: boolean) => Promise<void | undefined>;
 };

package/dist/types/cli/serverGlobalVars.d.ts

@@ -1,4 +1,6 @@
+import type { AppTools } from '@modern-js/app-tools';
 type SerializedGlobalVars = Record<string, string>;
-export declare const serializeServerGlobalVars: (options: unknown) => SerializedGlobalVars;
-export declare const transformServerGlobalVars: (outputDirectories: string[], globalVars: SerializedGlobalVars) => Promise<void>;
+type ServerGlobalVarsOptions = NonNullable<NonNullable<AppTools['config']>['source']>['globalVars'];
+export declare const serializeServerGlobalVars: (options: ServerGlobalVarsOptions) => SerializedGlobalVars;
+export declare const transformServerGlobalVars: (outputDirectories: string[], globalVars: SerializedGlobalVars) => Promise<undefined>;
 export {};

package/dist/types/cli.d.ts

@@ -1,2 +1,3 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 export declare const bffPlugin: () => CliPlugin<AppTools>;
+export default bffPlugin;

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

@@ -1,4 +1,4 @@
 import type { ServerPluginAPI } from '@modern-js/server-core';
 import { type ResolvedCrossProjectPolicy } from '../../../utils/crossProjectServerPolicy';
 import type { EffectApiModule } from '../module';
-export declare function resolveEffectAdapterCrossProjectPolicy(api: ServerPluginAPI, prefix: string, mod: EffectApiModule | null): Promise<ResolvedCrossProjectPolicy>;
+export declare function resolveEffectAdapterCrossProjectPolicy(api: ServerPluginAPI, prefix: string, mod: EffectApiModule | null): Promise<ResolvedCrossProjectPolicy | undefined>;

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

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

package/dist/types/runtime/effect/edge-dispatcher.d.ts

@@ -0,0 +1,26 @@
+import { type DispatchEffectBffRequestOptions } from './dispatch';
+import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions } from './handler';
+import { type EffectApiModule, type EffectBffRequestHandler } from './module';
+import type { EffectContext } from './operation-context';
+export { runWithEffectContext, useEffectContext, useOperationContext, } from './edge-context';
+export * from './handler';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
+export type EffectBffEdgeDispatchOptions = Omit<DispatchEffectBffRequestOptions, 'runWithEffectContext'>;
+export type EffectBffEdgeHandlerOptions = {
+    module: EffectApiModule;
+    prefix?: string;
+    openapi?: EffectBffOpenApiConfig;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    onError?: (error: unknown, context: EffectContext) => Promise<Response> | Response;
+    onWarning?: (message: string) => void;
+};
+export declare function dispatchEffectBffRequest(handler: EffectBffRequestHandler, request: Request, options?: EffectBffEdgeDispatchOptions): Promise<Response>;
+export declare function createEffectBffEdgeDispatcher(options: EffectBffEdgeHandlerOptions): Promise<{
+    dispatch: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
+    dispose: () => Promise<void>;
+}>;
+export declare const createEffectBffTestHandler: typeof createEffectBffEdgeHandler;
+export declare function createEffectBffEdgeHandler(options: EffectBffEdgeHandlerOptions): Promise<{
+    handler: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
+    dispose: () => Promise<void>;
+}>;

package/dist/types/runtime/effect/edge.d.ts

@@ -1,27 +1,2 @@
-import { type DispatchEffectBffRequestOptions } from './dispatch';
-import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions } from './handler';
-import { type EffectApiModule, type EffectBffRequestHandler } from './module';
-import type { EffectContext } from './operation-context';
 export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, type BackendFederatedEffectApiModule, type BackendFederationEntryExports, type BackendFederationExpectedIdentity, type BackendFederationIdentityIssue, type BackendFederationIdentityLoadOptions, type BackendFederationLoadEntryPluginOptions, type BackendFederationRemote, type BackendFederationRuntimeOptions, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi, validateExpectedBackendFederationIdentity, } from './backend-federation';
-export { runWithEffectContext, useEffectContext, useOperationContext, } from './edge-context';
-export * from './handler';
-export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
-export type EffectBffEdgeDispatchOptions = Omit<DispatchEffectBffRequestOptions, 'runWithEffectContext'>;
-export type EffectBffEdgeHandlerOptions = {
-    module: EffectApiModule;
-    prefix?: string;
-    openapi?: EffectBffOpenApiConfig;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-    onError?: (error: unknown, context: EffectContext) => Promise<Response> | Response;
-    onWarning?: (message: string) => void;
-};
-export declare function dispatchEffectBffRequest(handler: EffectBffRequestHandler, request: Request, options?: EffectBffEdgeDispatchOptions): Promise<Response>;
-export declare function createEffectBffEdgeDispatcher(options: EffectBffEdgeHandlerOptions): Promise<{
-    dispatch: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
-    dispose: () => Promise<void>;
-}>;
-export declare const createEffectBffTestHandler: typeof createEffectBffEdgeHandler;
-export declare function createEffectBffEdgeHandler(options: EffectBffEdgeHandlerOptions): Promise<{
-    handler: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
-    dispose: () => Promise<void>;
-}>;
+export * from './edge-dispatcher';

package/dist/types/runtime/effect/endpoint-contracts.d.ts

@@ -25,6 +25,12 @@ type HttpApiGroupLike = {
     identifier?: unknown;
 };
 type HttpApiEndpointLike = {
+    /**
+     * effect 4.0.0-beta.98 renamed the endpoint `name` property to `identifier`,
+     * matching `HttpApiGroup`. `name` is kept as a fallback so reflection over an
+     * older Effect build does not silently degrade to the class name.
+     */
+    identifier?: unknown;
     name?: unknown;
     method?: unknown;
     path?: unknown;

package/dist/types/runtime/effect/handler/definition.d.ts

@@ -1,17 +1,7 @@
 import type { HttpApi } from 'effect/unstable/httpapi';
 import type { Rpc } from 'effect/unstable/rpc';
-import type { EffectBffRuntime, EffectDataPlatformValidationOptions, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcRuntimeLayer, EffectRuntimeLayer } from './types';
-export declare function defineEffectBff<TApi extends HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any>(definition: {
-    api: TApi;
-    layer: TLayer;
-    rpc?: EffectRpcBffDefinition<TRpcs>;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-}): {
-    api: TApi;
-    layer: TLayer;
-    rpc?: EffectRpcBffDefinition<TRpcs>;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-} & EffectBffRuntime<TApi, TLayer>;
+import type { EffectBffDefinition, EffectBffRuntime, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcRuntimeLayer, EffectRuntimeLayer } from './types';
+export declare function defineEffectBff<TApi extends HttpApi.Constraint, TLayer extends EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any>(definition: EffectBffDefinition<TApi, TLayer, TRpcs>): EffectBffDefinition<TApi, TLayer, TRpcs> & EffectBffRuntime<TApi, TLayer>;
 export declare function defineEffectRpcBff<TRpcs extends Rpc.Any = Rpc.Any, TLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>>(definition: EffectRpcBffDefinition<TRpcs, TLayer>): EffectRpcBffDefinition<TRpcs, TLayer> & {
     createHandler: EffectRpcBffHandlerFactory<TRpcs>;
 };

package/dist/types/runtime/effect/handler/http.d.ts

@@ -1,12 +1,13 @@
 import type { HttpApi } from 'effect/unstable/httpapi';
 import type { Rpc } from 'effect/unstable/rpc';
-import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types';
-export declare function createHttpApiHandler<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TRpcs extends Rpc.Any = Rpc.Any>(options: {
+import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestInterceptor, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types';
+export declare function createHttpApiHandler<TApi extends HttpApi.Constraint = HttpApi.Top, TRpcs extends Rpc.Any = Rpc.Any>(options: {
     api: TApi;
     layer: EffectRuntimeLayer;
     openapi?: EffectBffOpenApiConfig;
     rpc?: EffectRpcBffDefinition<TRpcs>;
     dataPlatform?: EffectDataPlatformValidationOptions;
+    interceptRequest?: EffectRequestInterceptor;
     validateRequest?: EffectRequestValidator;
 }): {
     handler: (request: Request, context?: Parameters<(request: globalThis.Request, context: import("effect/Context").Context<unknown>) => Promise<Response>>[1]) => Promise<Response>;

package/dist/types/runtime/effect/handler/openapi.d.ts

@@ -1,4 +1,4 @@
 import { HttpRouter } from 'effect/unstable/http';
 import { type HttpApi } from 'effect/unstable/httpapi';
 import type { EffectBffOpenApiConfig } from './types';
-export declare function createOpenApiLayer(api: HttpApi.AnyWithProps, openapi: EffectBffOpenApiConfig | undefined): import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter> | null;
+export declare function createOpenApiLayer(api: HttpApi.Constraint, openapi: EffectBffOpenApiConfig | undefined): import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter> | null;

package/dist/types/runtime/effect/handler/types.d.ts

@@ -28,13 +28,14 @@ type EffectApiPromiseClient<TClient> = {
         [EndpointName in keyof TClient[GroupName]]: TClient[GroupName][EndpointName] extends (...args: infer TArgs) => infer TResult ? TResult extends EffectType.Effect<unknown, unknown, unknown> ? (...args: TArgs) => Promise<Exclude<EffectType.Success<TResult>, readonly [unknown, unknown]>> : never : never;
     };
 };
-export type EffectApiClientFromApi<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Any>, never, never> : never;
-export type EffectApiPromiseClientFromApi<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
-export type EffectBffDefinition<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
+export type EffectApiClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Constraint>, never, never> : never;
+export type EffectApiPromiseClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
+export type EffectBffDefinition<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
     api: TApi;
     layer: TLayer;
     rpc?: EffectRpcBffDefinition<TRpcs>;
     dataPlatform?: EffectDataPlatformValidationOptions;
+    interceptRequest?: EffectRequestInterceptor;
 };
 export type EffectDataPlatformSelectionValidationOptions = {
     maxDepth?: number;
@@ -131,13 +132,17 @@ export type EffectDataPlatformValidationOptions = {
  * cannot bypass it.
  */
 export type EffectRequestValidator = (request: Request) => Response | null | undefined;
-export type EffectBffHandlerFactory<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
+export type EffectRequestInterceptor = (options: {
+    request: Request;
+    next: () => Promise<Response>;
+}) => Response | Promise<Response>;
+export type EffectBffHandlerFactory<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
     openapi?: EffectBffOpenApiConfig;
     rpc?: Partial<EffectRpcBffHandlerOptions>;
     dataPlatform?: Partial<EffectDataPlatformValidationOptions>;
     validateRequest?: EffectRequestValidator;
 }) => ReturnType<typeof createHttpApiHandler>;
-export type EffectBffRuntime<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = {
+export type EffectBffRuntime<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = {
     createHandler: EffectBffHandlerFactory<TApi, TLayer>;
     client: EffectApiPromiseClientFromApi<TApi>;
 };

package/dist/types/runtime/effect-client/index.d.ts

@@ -53,6 +53,6 @@ export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean
 export declare function view<T>(): <const Selection extends EffectViewSelection<T>>(selection: Selection) => Selection;
 export declare function mask<T, const Selection extends EffectViewSelection<T>>(value: T, selection: Selection): EffectViewData<T, Selection>;
 export declare function runEffectView<T, const Selection extends EffectViewSelection<T>>(request: PromiseLike<T>, selection: Selection): Promise<EffectViewData<T, Selection>>;
-export declare function makeEffectHttpApiClient<ApiId extends string, Groups extends HttpApiGroup.Any>(api: HttpApi.HttpApi<ApiId, Groups>, options?: EffectHttpApiClientOptions): Effect.Effect<HttpApiClient.Client<Groups, never, never>, never, HttpApiGroup.MiddlewareClient<Groups>>;
+export declare function makeEffectHttpApiClient<ApiId extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<ApiId, Groups>, options?: EffectHttpApiClientOptions): Effect.Effect<HttpApiClient.Client<Groups, never, never>, never, HttpApiGroup.MiddlewareClient<Groups>>;
 export declare function makeEffectRpcClient<Rpcs extends Rpc.Any, const Flatten extends boolean = false>(group: RpcGroup.RpcGroup<Rpcs>, options: EffectRpcClientOptions<Rpcs, Flatten>): Effect.Effect<EffectRpcClientHandle<Rpcs, Flatten>, EffectRpcClientError, never>;
 export declare const runEffectRequest: <A, E>(effect: Effect.Effect<A, E>, options?: Effect.RunOptions | undefined) => Promise<A>;

package/dist/types/runtime/hono/adapter.d.ts

@@ -1,22 +1,28 @@
-import type { MiddlewareHandler, ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
-import { Hono } from '@modern-js/server-core';
+import type { ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
 import { type ResolvedCrossProjectPolicy } from '../../utils/crossProjectServerPolicy';
 interface MiddlewareOptions {
-    prefix: string;
+    prefix?: string;
     enableHandleWeb?: boolean;
 }
 export declare class HonoAdapter {
     apiMiddleware: ServerMiddleware[];
-    apiServer: Hono | null;
     api: ServerPluginAPI;
     isHono: boolean;
     prefix: string;
     crossProjectPolicy: ResolvedCrossProjectPolicy | undefined;
     constructor(api: ServerPluginAPI);
     setHandlers: () => Promise<void>;
-    registerApiRoutes: () => Promise<void>;
-    registerMiddleware: (options: MiddlewareOptions) => Promise<void>;
-    onApiHandlersUpdated: () => Promise<void>;
-    wrapInArray(handler: MiddlewareHandler[] | MiddlewareHandler): MiddlewareHandler[];
+    /**
+     * Register the BFF API routes as ordinary server middlewares.
+     *
+     * Dev and prod now share this single path: the routes are pushed straight
+     * into the server's middleware list. In dev, hot updates are handled by the
+     * unified `@modern-js/server` runtime reload (which rebuilds the whole
+     * runtime — including this plugin — from scratch), so BFF no longer needs its
+     * own swappable Hono sub-app / dynamic dispatch middleware.
+     */
+    registerMiddleware: (options?: MiddlewareOptions) => Promise<void>;
+    private handleRouteError;
+    private withErrorBoundary;
 }
 export {};

package/dist/types/utils/crossProjectApiPlugin.d.ts

@@ -5,5 +5,7 @@ export declare const API_DIR = "{apiDirectory}";
 export declare const LAMBDA_DIR = "{lambdaDirectory}";
 export declare const DIST_DIR = "{distDirectory}";
 export declare const RUNTIME_FRAMEWORK: string;
+export declare const EFFECT_ENTRY = "{effectEntry}";
+export declare const OPERATION_CONTRACTS_JSON = "{operationContracts}";
 export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>;
 export default crossProjectApiPlugin;

package/dist/types/utils/effectSourceLoader.d.ts

@@ -8,6 +8,16 @@ export declare function bundleEffectEntryForNode(options: {
     entryPath: string;
     format: 'cjs' | 'esm';
 }): Promise<void>;
+/**
+ * Loads the relocatable artifact emitted by the production BFF build.
+ *
+ * Production entries have already been compiled and bundled by
+ * `bundleEffectEntryForNode`. Loading that artifact through the development
+ * source-graph bundler a second time changes its module format and can strip
+ * CommonJS runtime globals from bundled dependencies. Keep the built module's
+ * native Node boundary intact instead.
+ */
+export declare function loadEffectBuiltModule(resourcePath: string): Promise<unknown>;
 /**
  * Loads an Effect source entry as native ESM while keeping its complete local
  * source graph observable by the framework watcher.

package/dist/types/utils/pluginGenerator.d.ts

@@ -1,9 +1,11 @@
-declare function pluginGenerator({ prefix, appDirectory, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, }: {
+declare function pluginGenerator({ prefix, appDirectory, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts, }: {
     prefix: string;
     appDirectory: string;
     relativeDistPath: string;
     relativeApiPath: string;
     relativeLambdaPath: string;
     runtimeFramework: 'hono' | 'effect';
+    relativeEffectEntry: string;
+    operationContracts: Record<string, unknown>;
 }): Promise<void>;
 export default pluginGenerator;