@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.102 → 3.5.0-ultramodern.103

package/dist/cjs/cli/compress.js

@@ -32,7 +32,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_prefix_js_namespaceObject = require("./prefix.js");
 const createCompressConfig = (devServer, prefix)=>{
-    if (!devServer || 'object' != typeof devServer || Array.isArray(devServer)) return;
+    if (void 0 === devServer || 'object' != typeof devServer || Array.isArray(devServer)) return;
     const { compress } = devServer;
     if (void 0 === compress || true === compress) {
         const prefixes = (0, external_prefix_js_namespaceObject.normalizePrefixList)(prefix);

package/dist/cjs/cli/generator.js

@@ -42,8 +42,6 @@ __webpack_require__.d(__webpack_exports__, {
 const bff_core_namespaceObject = require("@modern-js/bff-core");
 const server_utils_namespaceObject = require("@modern-js/server-utils");
 const utils_namespaceObject = require("@modern-js/utils");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const clientGenerator_js_namespaceObject = require("../utils/clientGenerator.js");
 var clientGenerator_js_default = /*#__PURE__*/ __webpack_require__.n(clientGenerator_js_namespaceObject);
 const effectSourceLoader_js_namespaceObject = require("../utils/effectSourceLoader.js");
@@ -65,121 +63,121 @@ const effectEntryExtensions = [
     '.cts'
 ];
 function resolveEffectSourceEntry(appDirectory, apiDirectory, configuredEntry) {
-    const entry = configuredEntry ? external_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_path_default().resolve(appDirectory, configuredEntry) : external_path_default().resolve(apiDirectory, 'index');
-    return external_path_default().extname(entry) ? entry : effectEntryExtensions.map((extension)=>`${entry}${extension}`).find((candidate)=>utils_namespaceObject.fs.existsSync(candidate));
+    const entry = void 0 !== configuredEntry && configuredEntry.length > 0 ? utils_namespaceObject.upath.isAbsolute(configuredEntry) ? configuredEntry : utils_namespaceObject.upath.resolve(appDirectory, configuredEntry) : utils_namespaceObject.upath.resolve(apiDirectory, 'index');
+    return utils_namespaceObject.upath.extname(entry).length > 0 ? entry : effectEntryExtensions.map((extension)=>`${entry}${extension}`).find((candidate)=>utils_namespaceObject.fs.existsSync(candidate));
 }
 function resolveBuiltEffectEntry(appDirectory, distDirectory, sourceEntry) {
-    if (!sourceEntry) return;
-    const relativeEntry = external_path_default().relative(appDirectory, sourceEntry);
-    if ('..' === relativeEntry || relativeEntry.startsWith(`..${external_path_default().sep}`)) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
-    const builtEntry = external_path_default().resolve(distDirectory, relativeEntry).replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
+    if (void 0 === sourceEntry || 0 === sourceEntry.length) return;
+    const relativeEntry = utils_namespaceObject.upath.relative(appDirectory, sourceEntry);
+    if ('..' === relativeEntry || relativeEntry.startsWith(`..${utils_namespaceObject.upath.sep}`)) throw new Error(`Effect BFF entry must be inside the application directory: ${sourceEntry}`);
+    const builtEntry = utils_namespaceObject.upath.resolve(distDirectory, relativeEntry).replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
     return utils_namespaceObject.fs.existsSync(builtEntry) ? builtEntry : void 0;
 }
 const createBffGenerator = (api)=>{
-    const compileApi = async ()=>{
-        const { appDirectory, distDirectory, apiDirectory, bffRuntimeFramework, sharedDirectory, moduleType } = api.getAppContext();
-        const modernConfig = api.getNormalizedConfig();
-        const distDir = external_path_default().resolve(distDirectory);
-        const apiDir = apiDirectory || external_path_default().resolve(appDirectory, utils_namespaceObject.API_DIR);
-        const sharedDir = sharedDirectory || external_path_default().resolve(appDirectory, utils_namespaceObject.SHARED_DIR);
-        const tsconfigPath = (0, utils_namespaceObject.resolveServerTsconfig)(appDirectory, modernConfig?.server?.tsconfigPath);
-        const sourceDirs = [];
-        if (await utils_namespaceObject.fs.pathExists(apiDir)) sourceDirs.push(apiDir);
-        if (await utils_namespaceObject.fs.pathExists(sharedDir)) sourceDirs.push(sharedDir);
-        const { alias, globalVars } = modernConfig.source;
-        const { alias: resolveAlias } = modernConfig.resolve;
-        if (sourceDirs.length > 0) {
-            const combinedAlias = [].concat(alias ?? []).concat(resolveAlias ?? []);
-            const serializedGlobalVars = (0, external_serverGlobalVars_js_namespaceObject.serializeServerGlobalVars)(globalVars);
-            await (0, server_utils_namespaceObject.compile)(appDirectory, {
-                alias: combinedAlias
-            }, {
-                sourceDirs,
-                distDir,
-                tsconfigPath,
-                moduleType,
-                throwErrorInsteadOfExit: true
-            });
-            await (0, external_serverGlobalVars_js_namespaceObject.transformServerGlobalVars)(sourceDirs.map((sourceDir)=>external_path_default().resolve(distDir, external_path_default().relative(appDirectory, sourceDir))), serializedGlobalVars);
-            if ('effect' === bffRuntimeFramework) {
-                const sourceEntry = resolveEffectSourceEntry(appDirectory, apiDir, modernConfig.bff?.effect?.entry);
-                const builtEntry = resolveBuiltEffectEntry(appDirectory, distDir, sourceEntry);
-                if (!builtEntry) throw new Error(`Effect BFF entry was not emitted into ${distDir}: ${sourceEntry ?? external_path_default().resolve(apiDir, 'index')}`);
-                await (0, effectSourceLoader_js_namespaceObject.bundleEffectEntryForNode)({
-                    appDir: appDirectory,
-                    entryPath: builtEntry,
-                    format: 'module' === moduleType ? 'esm' : 'cjs'
+    const compileApi = ()=>Promise.resolve().then(()=>{
+            const { appDirectory, distDirectory, apiDirectory, bffRuntimeFramework, sharedDirectory, moduleType } = api.getAppContext();
+            const modernConfig = api.getNormalizedConfig();
+            const distDir = utils_namespaceObject.upath.resolve(distDirectory);
+            const apiDir = apiDirectory || utils_namespaceObject.upath.resolve(appDirectory, utils_namespaceObject.API_DIR);
+            const sharedDir = sharedDirectory || utils_namespaceObject.upath.resolve(appDirectory, utils_namespaceObject.SHARED_DIR);
+            const tsconfigPath = (0, utils_namespaceObject.resolveServerTsconfig)(appDirectory, modernConfig?.server?.tsconfigPath);
+            const sourceDirs = [];
+            return utils_namespaceObject.fs.pathExists(apiDir).then((apiDirectoryExists)=>{
+                if (apiDirectoryExists) sourceDirs.push(apiDir);
+                return utils_namespaceObject.fs.pathExists(sharedDir);
+            }).then((sharedDirectoryExists)=>{
+                if (sharedDirectoryExists) sourceDirs.push(sharedDir);
+                if (0 === sourceDirs.length) return;
+                const { alias, globalVars } = modernConfig.source;
+                const { alias: resolveAlias } = modernConfig.resolve;
+                const combinedAlias = [].concat(alias ?? []).concat(resolveAlias ?? []);
+                const serializedGlobalVars = (0, external_serverGlobalVars_js_namespaceObject.serializeServerGlobalVars)(globalVars);
+                return (0, server_utils_namespaceObject.compile)(appDirectory, {
+                    alias: combinedAlias
+                }, {
+                    sourceDirs,
+                    distDir,
+                    tsconfigPath,
+                    moduleType,
+                    throwErrorInsteadOfExit: true
+                }).then(()=>(0, external_serverGlobalVars_js_namespaceObject.transformServerGlobalVars)(sourceDirs.map((sourceDir)=>utils_namespaceObject.upath.resolve(distDir, utils_namespaceObject.upath.relative(appDirectory, sourceDir))), serializedGlobalVars)).then(()=>{
+                    if ('effect' !== bffRuntimeFramework) return;
+                    const sourceEntry = resolveEffectSourceEntry(appDirectory, apiDir, modernConfig.bff?.effect?.entry);
+                    const builtEntry = resolveBuiltEffectEntry(appDirectory, 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')}`);
+                    return (0, effectSourceLoader_js_namespaceObject.bundleEffectEntryForNode)({
+                        appDir: appDirectory,
+                        entryPath: builtEntry,
+                        format: 'module' === moduleType ? 'esm' : 'cjs'
+                    });
                 });
-            }
-        }
-    };
-    const generate = async ()=>{
-        const { appDirectory, apiDirectory, lambdaDirectory, port, bffRuntimeFramework } = api.getAppContext();
-        const modernConfig = api.getNormalizedConfig();
-        const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
-        const { bff } = modernConfig || {};
-        const prefix = (0, external_prefix_js_namespaceObject.getPrimaryPrefix)(bff?.prefix);
-        const httpMethodDecider = bff?.httpMethodDecider;
-        const apiRouter = new bff_core_namespaceObject.ApiRouter({
-            apiDir: apiDirectory,
-            appDir: appDirectory,
-            lambdaDir: lambdaDirectory,
-            prefix,
-            httpMethodDecider,
-            isBuild: true
-        });
-        const lambdaDir = apiRouter.getLambdaDir();
-        const existLambda = apiRouter.isExistLambda();
-        const packageJson = utils_namespaceObject.fs.readJSONSync(external_path_default().resolve(appDirectory, 'package.json'));
-        const requestId = packageJson.name || process.env.npm_package_name;
-        const operationContracts = existLambda ? (0, bff_core_namespaceObject.buildOperationContractMap)({
-            handlers: await apiRouter.getApiHandlers(),
-            requestId,
-            operationVersion: (0, bff_core_namespaceObject.deriveOperationVersion)(packageJson.version)
-        }) : {};
-        const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
-        const relativeApiPath = external_path_default().relative(appDirectory, apiDirectory);
-        const relativeLambdaPath = external_path_default().relative(appDirectory, lambdaDir);
-        const sourceEffectEntry = 'effect' === bffRuntimeFramework ? resolveEffectSourceEntry(appDirectory, apiDirectory, bff?.effect?.entry) : void 0;
-        const relativeEffectEntry = sourceEffectEntry ? external_path_default().relative(appDirectory, sourceEffectEntry).replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js') : '';
-        await pluginGenerator_js_default()({
-            prefix,
-            appDirectory,
-            relativeDistPath,
-            relativeApiPath,
-            relativeLambdaPath,
-            runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect',
-            relativeEffectEntry,
-            operationContracts
+            });
         });
-        await clientGenerator_js_default()({
-            prefix,
-            appDir: appDirectory,
-            apiDir: apiDirectory,
-            lambdaDir,
-            existLambda,
-            port,
-            requestCreator: bff?.requestCreator,
-            httpMethodDecider,
-            relativeDistPath,
-            relativeApiPath,
-            bffRuntimeFramework,
-            effectEntry: bff?.effect?.entry,
-            effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+    const generate = ()=>Promise.resolve().then(()=>{
+            const { appDirectory, apiDirectory, lambdaDirectory, port, bffRuntimeFramework, packageName } = api.getAppContext();
+            const modernConfig = api.getNormalizedConfig();
+            const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
+            const { bff } = modernConfig || {};
+            const prefix = (0, external_prefix_js_namespaceObject.getPrimaryPrefix)(bff?.prefix);
+            const httpMethodDecider = bff?.httpMethodDecider;
+            const apiRouter = new bff_core_namespaceObject.ApiRouter({
+                apiDir: apiDirectory,
+                appDir: appDirectory,
+                lambdaDir: lambdaDirectory,
+                prefix,
+                httpMethodDecider,
+                isBuild: true
+            });
+            const lambdaDir = apiRouter.getLambdaDir();
+            const existLambda = apiRouter.isExistLambda();
+            const packageJson = utils_namespaceObject.fs.readJSONSync(utils_namespaceObject.upath.resolve(appDirectory, 'package.json'));
+            const requestId = packageJson.name || packageName;
+            const operationContractsPromise = existLambda ? apiRouter.getApiHandlers().then((handlers)=>(0, bff_core_namespaceObject.buildOperationContractMap)({
+                    handlers,
+                    requestId,
+                    operationVersion: (0, bff_core_namespaceObject.deriveOperationVersion)(packageJson.version)
+                })) : Promise.resolve({});
+            return operationContractsPromise.then((operationContracts)=>{
+                const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
+                const relativeApiPath = utils_namespaceObject.upath.relative(appDirectory, apiDirectory);
+                const relativeLambdaPath = utils_namespaceObject.upath.relative(appDirectory, lambdaDir);
+                const sourceEffectEntry = 'effect' === bffRuntimeFramework ? resolveEffectSourceEntry(appDirectory, apiDirectory, bff?.effect?.entry) : void 0;
+                const relativeEffectEntry = void 0 !== sourceEffectEntry && sourceEffectEntry.length > 0 ? utils_namespaceObject.upath.relative(appDirectory, sourceEffectEntry).replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js') : '';
+                return pluginGenerator_js_default()({
+                    prefix,
+                    appDirectory,
+                    relativeDistPath,
+                    relativeApiPath,
+                    relativeLambdaPath,
+                    runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect',
+                    relativeEffectEntry,
+                    operationContracts
+                }).then(()=>clientGenerator_js_default()({
+                        prefix,
+                        appDir: appDirectory,
+                        apiDir: apiDirectory,
+                        lambdaDir,
+                        existLambda,
+                        port,
+                        requestCreator: bff?.requestCreator,
+                        httpMethodDecider,
+                        relativeDistPath,
+                        relativeApiPath,
+                        bffRuntimeFramework,
+                        effectEntry: bff?.effect?.entry,
+                        effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+                    })).then(()=>runtimeGenerator_js_default()({
+                        runtime,
+                        appDirectory,
+                        relativeDistPath
+                    }));
+            });
         });
-        await runtimeGenerator_js_default()({
-            runtime,
-            appDirectory,
-            relativeDistPath
+    const handleCrossProjectInvocation = (isBuild = false)=>Promise.resolve().then(()=>{
+            const { bff } = api.getNormalizedConfig();
+            if (bff?.crossProject !== true) return;
+            return isBuild ? generate() : compileApi().then(()=>generate());
         });
-    };
-    const handleCrossProjectInvocation = async (isBuild = false)=>{
-        const { bff } = api.getNormalizedConfig();
-        if (bff?.crossProject) {
-            if (!isBuild) await compileApi();
-            await generate();
-        }
-    };
     return {
         compileApi,
         generate,

package/dist/cjs/cli/serverGlobalVars.js

@@ -1,14 +1,5 @@
 "use strict";
 var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -42,26 +33,20 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const utils_namespaceObject = require("@modern-js/utils");
 const core_namespaceObject = require("@swc/core");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const RELEASE_IDENTITY_GLOBAL_NAMES = [
     'ULTRAMODERN_BUILD_MARKER',
     'ULTRAMODERN_SOURCE_REVISION',
     'ULTRAMODERN_RELEASE_VERSION'
 ];
-const collectJavaScriptFiles = async (directory)=>{
-    const entries = await utils_namespaceObject.fs.readdir(directory, {
-        withFileTypes: true
-    });
-    const nested = await Promise.all(entries.map(async (entry)=>{
-        const absolutePath = external_path_default().join(directory, entry.name);
-        if (entry.isDirectory()) return collectJavaScriptFiles(absolutePath);
-        return /\.(?:c|m)?js$/u.test(entry.name) ? [
-            absolutePath
-        ] : [];
-    }));
-    return nested.flat();
-};
+const collectJavaScriptFiles = (directory)=>Promise.resolve().then(()=>utils_namespaceObject.fs.readdir(directory, {
+            withFileTypes: true
+        })).then((entries)=>Promise.all(entries.map((entry)=>{
+            const absolutePath = utils_namespaceObject.upath.join(directory, entry.name);
+            if (entry.isDirectory()) return collectJavaScriptFiles(absolutePath);
+            return /\.(?:c|m)?js$/u.test(entry.name) ? [
+                absolutePath
+            ] : [];
+        })).then((nested)=>nested.flat()));
 const serializeServerGlobalVars = (options)=>{
     const globalVars = (0, utils_namespaceObject.applyOptionsChain)({}, options, {
         env: 'server',
@@ -83,39 +68,40 @@ const serializeServerGlobalVars = (options)=>{
         ];
     }));
 };
-const transformServerGlobalVars = async (outputDirectories, globalVars)=>{
-    if (0 === Object.keys(globalVars).length) return;
-    const existingDirectories = (await Promise.all(outputDirectories.map(async (directory)=>await utils_namespaceObject.fs.pathExists(directory) ? directory : void 0))).filter((directory)=>Boolean(directory));
-    const files = (await Promise.all(existingDirectories.map(collectJavaScriptFiles))).flat();
-    const releaseIdentityBanner = RELEASE_IDENTITY_GLOBAL_NAMES.every((name)=>Object.hasOwn(globalVars, name)) ? `${RELEASE_IDENTITY_GLOBAL_NAMES.map((name)=>`void ${globalVars[name]};`).join('')}\n` : '';
-    await Promise.all(files.map(async (filename)=>{
-        const source = await utils_namespaceObject.fs.readFile(filename, 'utf8');
-        const sourceMapFilename = `${filename}.map`;
-        const sourceMapExists = await utils_namespaceObject.fs.pathExists(sourceMapFilename);
-        const inputSourceMap = sourceMapExists ? await utils_namespaceObject.fs.readFile(sourceMapFilename, 'utf8') : void 0;
-        const result = await (0, core_namespaceObject.transform)(`${releaseIdentityBanner}${source}`, {
-            filename,
-            inputSourceMap,
-            sourceMaps: sourceMapExists,
-            jsc: {
-                parser: {
-                    syntax: "ecmascript"
-                },
-                preserveAllComments: true,
-                target: 'es2022',
-                transform: {
-                    optimizer: {
-                        globals: {
-                            vars: globalVars
-                        }
-                    }
-                }
-            }
-        });
-        await utils_namespaceObject.fs.writeFile(filename, result.code);
-        if (sourceMapExists && result.map) await utils_namespaceObject.fs.writeFile(sourceMapFilename, result.map);
-    }));
-};
+const transformServerGlobalVars = (outputDirectories, globalVars)=>Promise.resolve().then(()=>{
+        if (0 === Object.keys(globalVars).length) return;
+        return Promise.all(outputDirectories.map((directory)=>utils_namespaceObject.fs.pathExists(directory).then((directoryExists)=>directoryExists ? directory : void 0))).then((existingDirectories)=>{
+            const filesPromise = Promise.all(existingDirectories.filter((directory)=>void 0 !== directory).map(collectJavaScriptFiles)).then((files)=>files.flat());
+            const releaseIdentityBanner = RELEASE_IDENTITY_GLOBAL_NAMES.every((name)=>Object.hasOwn(globalVars, name)) ? `${RELEASE_IDENTITY_GLOBAL_NAMES.map((name)=>`void ${globalVars[name]};`).join('')}\n` : '';
+            return filesPromise.then((files)=>Promise.all(files.map((filename)=>utils_namespaceObject.fs.readFile(filename, 'utf8').then((source)=>{
+                        const sourceMapFilename = `${filename}.map`;
+                        return utils_namespaceObject.fs.pathExists(sourceMapFilename).then((sourceMapExists)=>{
+                            const inputSourceMapPromise = sourceMapExists ? utils_namespaceObject.fs.readFile(sourceMapFilename, 'utf8') : Promise.resolve(void 0);
+                            return inputSourceMapPromise.then((inputSourceMap)=>(0, core_namespaceObject.transform)(`${releaseIdentityBanner}${source}`, {
+                                    filename,
+                                    inputSourceMap,
+                                    sourceMaps: sourceMapExists,
+                                    jsc: {
+                                        parser: {
+                                            syntax: "ecmascript"
+                                        },
+                                        preserveAllComments: true,
+                                        target: 'es2022',
+                                        transform: {
+                                            optimizer: {
+                                                globals: {
+                                                    vars: globalVars
+                                                }
+                                            }
+                                        }
+                                    }
+                                }).then((result)=>utils_namespaceObject.fs.writeFile(filename, result.code).then(()=>{
+                                        if (sourceMapExists && void 0 !== result.map && result.map.length > 0) return utils_namespaceObject.fs.writeFile(sourceMapFilename, result.map);
+                                    })));
+                        });
+                    }))));
+        }).then(()=>void 0);
+    });
 exports.serializeServerGlobalVars = __webpack_exports__.serializeServerGlobalVars;
 exports.transformServerGlobalVars = __webpack_exports__.transformServerGlobalVars;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/loader.js

@@ -68,7 +68,7 @@ async function transformEffectRuntimeSource(source, filename) {
 function createEffectWorkerRuntimeWrapper(resourcePath) {
     const sourceRequest = `${resourcePath}?${EFFECT_BFF_WORKER_RUNTIME_SOURCE_QUERY}`;
     return `import * as effectBffModule from ${JSON.stringify(sourceRequest)};
-import { createEffectBffEdgeDispatcher } from '@modern-js/plugin-bff/effect-edge';
+import { createEffectBffEdgeDispatcher } from '@modern-js/plugin-bff/effect-edge/dispatcher';
 
 export const __modern_create_effect_bff_dispatcher = options =>
   createEffectBffEdgeDispatcher({

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

@@ -34,23 +34,28 @@ const utils_namespaceObject = require("@modern-js/utils");
 const httpapi_namespaceObject = require("effect/unstable/httpapi");
 const crossProjectServerPolicy_js_namespaceObject = require("../../../utils/crossProjectServerPolicy.js");
 const external_endpoint_contracts_js_namespaceObject = require("../endpoint-contracts.js");
-async function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
-    let contractSources = [];
-    if (mod) try {
-        const effectApi = await (0, external_endpoint_contracts_js_namespaceObject.extractHttpApiFromModule)(mod, httpapi_namespaceObject.HttpApi.isHttpApi);
-        if (effectApi) {
-            const reflect = (apiValue, handlers)=>httpapi_namespaceObject.HttpApi.reflect(apiValue, {
+function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
+    const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>(0, external_endpoint_contracts_js_namespaceObject.extractHttpApiFromModule)(mod, httpapi_namespaceObject.HttpApi.isHttpApi)).then((effectApi)=>{
+        if (null !== effectApi) {
+            const reflect = (apiValue, handlers)=>{
+                if (!httpapi_namespaceObject.HttpApi.isHttpApi(apiValue)) throw new Error('[BFF][Effect] Endpoint reflection received a non-HttpApi value.');
+                httpapi_namespaceObject.HttpApi.reflect(apiValue, {
                     onGroup: handlers.onGroup ?? (()=>{}),
                     onEndpoint: handlers.onEndpoint
                 });
-            contractSources = (0, external_endpoint_contracts_js_namespaceObject.toOperationContractSources)((0, external_endpoint_contracts_js_namespaceObject.collectEffectEndpoints)(reflect, effectApi, prefix));
+            };
+            return (0, external_endpoint_contracts_js_namespaceObject.toOperationContractSources)((0, external_endpoint_contracts_js_namespaceObject.collectEffectEndpoints)(reflect, effectApi, prefix));
         }
-    } catch (error) {
+        return [];
+    }).catch((error)=>{
         utils_namespaceObject.logger.warn(`[BFF][Effect] Failed reflect HttpApi endpoints cross-project policy: ${String(error)}`);
-    }
-    const policy = (0, crossProjectServerPolicy_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources);
-    if (policy?.enabled && 0 === contractSources.length) utils_namespaceObject.logger.warn('[BFF][Effect] Cross-project policy enabled but no HttpApi endpoints could be reflected; requests fail operation-contract matching unless allowUnknownOperations is enabled.');
-    return policy;
+        return [];
+    });
+    return contractSourcesPromise.then((contractSources)=>{
+        const policy = (0, crossProjectServerPolicy_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources);
+        if (policy?.enabled === true && 0 === contractSources.length) utils_namespaceObject.logger.warn('[BFF][Effect] Cross-project policy enabled but no HttpApi endpoints could be reflected; requests fail operation-contract matching unless allowUnknownOperations is enabled.');
+        return policy;
+    });
 }
 exports.resolveEffectAdapterCrossProjectPolicy = __webpack_exports__.resolveEffectAdapterCrossProjectPolicy;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/runtime/effect/adapter/error-response.js

@@ -32,23 +32,25 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const utils_namespaceObject = require("@modern-js/utils");
 const external_safe_failure_js_namespaceObject = require("../../safe-failure.js");
-async function createEffectAdapterRuntimeErrorResponse(api, error, c) {
+function createEffectAdapterRuntimeErrorResponse(api, error, c) {
     try {
         const serverConfig = api.getServerConfig();
         const onErrorHandler = serverConfig?.onError;
-        if (onErrorHandler) {
+        if (void 0 !== onErrorHandler) {
             const onErrorContext = ensureJsonContext(c);
-            const result = await onErrorHandler(error instanceof Error ? error : new Error(String(error)), onErrorContext);
-            if (result instanceof Response) return result;
-        } else utils_namespaceObject.logger.error(error);
+            return Promise.resolve(onErrorHandler(error instanceof Error ? error : new Error(String(error)), onErrorContext)).then((result)=>result instanceof Response ? result : (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error)).catch((configError)=>{
+                utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${String(configError)}`);
+                return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error);
+            });
+        }
+        utils_namespaceObject.logger.error(error instanceof Error ? error : new Error(String(error)));
     } catch (configError) {
         utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${configError}`);
     }
-    return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error);
+    return Promise.resolve((0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error));
 }
 function ensureJsonContext(c) {
-    const maybeJsonContext = c;
-    if ('function' == typeof maybeJsonContext.json) return c;
+    if ('json' in c && 'function' == typeof c.json) return c;
     const headers = {
         'content-type': 'application/json; charset=utf-8'
     };
@@ -59,7 +61,7 @@ function ensureJsonContext(c) {
                 headers: extraHeaders
             } : statusOrInit;
             const responseHeaders = new Headers(headers);
-            if (responseInit.headers) new Headers(responseInit.headers).forEach((value, key)=>{
+            if (void 0 !== responseInit.headers) new Headers(responseInit.headers).forEach((value, key)=>{
                 responseHeaders.set(key, value);
             });
             return new Response(JSON.stringify(data), {

package/dist/cjs/runtime/effect/adapter.js

@@ -71,10 +71,10 @@ class EffectAdapter {
         let mod;
         try {
             const { appDirectory } = this.api.getServerContext();
-            mod = await (0, effectSourceLoader_js_namespaceObject.loadEffectSourceModule)({
+            mod = await ((0, utils_namespaceObject.isProd)() ? (0, effectSourceLoader_js_namespaceObject.loadEffectBuiltModule)(entryFile) : (0, effectSourceLoader_js_namespaceObject.loadEffectSourceModule)({
                 resourcePath: entryFile,
                 appDir: appDirectory || external_path_default().dirname(entryFile)
-            });
+            }));
         } catch (error) {
             utils_namespaceObject.logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
             this.handler = null;

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

@@ -31,31 +31,40 @@ __webpack_require__.d(__webpack_exports__, {
     loadBackendFederatedEffectApi: ()=>loadBackendFederatedEffectApi
 });
 const universal_namespaceObject = require("@modern-js/utils/universal");
+const Effect_namespaceObject = require("effect/Effect");
+const Logger_namespaceObject = require("effect/Logger");
 const external_identity_js_namespaceObject = require("./identity.js");
 const external_runtime_js_namespaceObject = require("./runtime.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const LEGACY_LOAD_WARNING = '[BFF][Effect] loadBackendFederatedEffectApi was called without an expected delivery-unit identity (expected.unitId + expected.buildMarker). Identity-less public backend loads are deprecated (ADR-0019/MV-G23) and will be rejected in a future major.';
-async function loadBackendFederatedEffectApi(options) {
+const legacyWarningLogger = Logger_namespaceObject.withLeveledConsole(Logger_namespaceObject.formatLogFmt);
+function warnLegacyLoad() {
+    Effect_namespaceObject.runSync(Effect_namespaceObject.provideService(Effect_namespaceObject.logWarning(LEGACY_LOAD_WARNING), Logger_namespaceObject.CurrentLoggers, new Set([
+        legacyWarningLogger
+    ])));
+}
+function loadBackendFederatedEffectApi(options) {
     const remoteName = options.remote?.name ?? options.remoteName;
-    if (!remoteName) throw new Error('[BFF][Effect] Missing backend federation remote name.');
-    if (void 0 === options.expected) console.warn(LEGACY_LOAD_WARNING);
+    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();
     const runtime = options.runtime ?? (0, external_runtime_js_namespaceObject.createBackendFederationRuntime)(options);
     const expose = options.expose ?? options.remote?.expose ?? universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
     const remoteRequest = `${remoteName}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)}`;
-    const loaded = await runtime.loadRemote(remoteRequest);
-    if (!(0, external_utils_js_namespaceObject.isRecord)(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must load an object module.`);
-    const backendContract = loaded.backendFederationContract;
-    if (!(0, external_utils_js_namespaceObject.isRecord)(backendContract) || true !== backendContract.strictEffectApproach) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (strictEffectApproach: true).`);
-    if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
-    if ('string' == typeof backendContract.name && backendContract.name !== remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} metadata name mismatch: expected ${remoteName}, received ${backendContract.name}.`);
-    if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose api and runtime.`);
-    if (void 0 !== options.expected) {
-        const issues = (0, external_identity_js_namespaceObject.validateExpectedBackendFederationIdentity)(loaded, options.expected, {
-            allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
-        });
-        if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} delivery-unit identity mismatch: ${(0, external_identity_js_namespaceObject.formatBackendFederationIdentityIssues)(issues)}.`);
-    }
-    return loaded;
+    return runtime.loadRemote(remoteRequest).then((loaded)=>{
+        if (!(0, external_utils_js_namespaceObject.isRecord)(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must load an object module.`);
+        const backendContract = loaded.backendFederationContract;
+        if (!(0, external_utils_js_namespaceObject.isRecord)(backendContract) || true !== backendContract.strictEffectApproach) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (strictEffectApproach: true).`);
+        if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
+        if ('string' == typeof backendContract.name && backendContract.name !== remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} metadata name mismatch: expected ${remoteName}, received ${backendContract.name}.`);
+        if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} must expose api and runtime.`);
+        if (void 0 !== options.expected) {
+            const issues = (0, external_identity_js_namespaceObject.validateExpectedBackendFederationIdentity)(loaded, options.expected, {
+                allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
+            });
+            if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${remoteRequest} delivery-unit identity mismatch: ${(0, external_identity_js_namespaceObject.formatBackendFederationIdentityIssues)(issues)}.`);
+        }
+        return loaded;
+    });
 }
 exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/runtime/effect/backend-federation/plugin.js

@@ -30,13 +30,23 @@ __webpack_require__.r(__webpack_exports__);
 function createBackendFederationLoadEntryPlugin(options) {
     return {
         name: 'modernjs-backend-federation-load-entry',
-        async loadEntry ({ remoteInfo }) {
-            return options.resolveEntry({
+        loadEntry ({ remoteInfo }) {
+            return Promise.resolve(options.resolveEntry({
                 name: remoteInfo.name,
                 entry: remoteInfo.entry,
                 type: remoteInfo.type,
                 entryGlobalName: remoteInfo.entryGlobalName,
                 shareScope: remoteInfo.shareScope
+            })).then((entry)=>{
+                if (void 0 === entry) return;
+                return {
+                    get (id) {
+                        return ()=>Promise.resolve(entry.get(id)).then((factory)=>factory());
+                    },
+                    init (...args) {
+                        return entry.init?.(...args);
+                    }
+                };
             });
         }
     };

package/dist/cjs/runtime/effect/backend-federation/remotes.js

@@ -31,10 +31,11 @@ function collectRemotes(options) {
     const remotes = [
         ...options.remotes ?? []
     ];
-    if (options.remote) {
-        const existingIndex = remotes.findIndex((remote)=>remote.name === options.remote?.name);
-        if (existingIndex >= 0) remotes[existingIndex] = options.remote;
-        else remotes.push(options.remote);
+    const configuredRemote = options.remote;
+    if (void 0 !== configuredRemote) {
+        const existingIndex = remotes.findIndex((remote)=>remote.name === configuredRemote.name);
+        if (existingIndex >= 0) remotes[existingIndex] = configuredRemote;
+        else remotes.push(configuredRemote);
     }
     return remotes;
 }