@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

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

@@ -0,0 +1,199 @@
+"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)=>{
+            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__, {
+    default: ()=>effect_server
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+require("@modern-js/server-runtime-extensions/server-config");
+const effect_namespaceObject = require("@modern-js/bff-effect/effect");
+const node_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy/node");
+const runtime_lifecycle_namespaceObject = require("@modern-js/server-runtime-extensions/runtime-lifecycle");
+const utils_namespaceObject = require("@modern-js/utils");
+const evaluation_js_namespaceObject = require("../cross-project-policy/evaluation.js");
+const loader_js_namespaceObject = require("../effect-source-loader/loader.js");
+const external_cross_project_policy_js_namespaceObject = require("./cross-project-policy.js");
+const external_entry_js_namespaceObject = require("./entry.js");
+const external_error_response_js_namespaceObject = require("./error-response.js");
+const EFFECT_MIDDLEWARE_BEFORE = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+const effect_server = ()=>({
+        name: '@modern-js/plugin-bff-extensions/effect-server',
+        setup (api) {
+            const runtimeFramework = api.getServerContext().bffRuntimeFramework;
+            if ('effect' !== runtimeFramework) throw new Error(`Effect BFF server plugin requires Effect; received "${runtimeFramework}".`);
+            let handler = null;
+            let unregisterRuntimeDisposer;
+            let prefix = '/api';
+            let prefixes = [
+                '/api'
+            ];
+            let matchingPrefixes = [
+                '/api'
+            ];
+            let retired = false;
+            const dispose = async ()=>{
+                retired = true;
+                unregisterRuntimeDisposer?.();
+                unregisterRuntimeDisposer = void 0;
+                const previous = handler;
+                handler = null;
+                await previous?.dispose();
+            };
+            const loadHandler = async ()=>{
+                const entryFile = (0, external_entry_js_namespaceObject.resolveEffectServerEntryFile)(api);
+                if (!entryFile || !await utils_namespaceObject.fs.pathExists(entryFile)) {
+                    handler = null;
+                    return;
+                }
+                const { appDirectory } = api.getServerContext();
+                let mod;
+                try {
+                    mod = await ((0, utils_namespaceObject.isProd)() ? (0, loader_js_namespaceObject.loadEffectBuiltModule)(entryFile) : (0, loader_js_namespaceObject.loadEffectSourceModule)({
+                        resourcePath: entryFile,
+                        appDir: appDirectory || external_node_path_default().dirname(entryFile)
+                    }));
+                } catch (error) {
+                    utils_namespaceObject.logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
+                    throw error;
+                }
+                const producer = (0, node_namespaceObject.resolveOperationProducer)({
+                    directories: [
+                        external_node_path_default().dirname(entryFile),
+                        appDirectory
+                    ],
+                    requestId: api.getServerConfig()?.bff?.requestId
+                });
+                const crossProjectPolicies = new Map(await Promise.all(prefixes.map(async (prefix)=>[
+                        prefix,
+                        await (0, external_cross_project_policy_js_namespaceObject.resolveEffectServerCrossProjectPolicy)(api, prefix, mod, producer)
+                    ])));
+                const effectConfig = api.getServerConfig()?.bff?.effect;
+                const loaded = await (0, effect_namespaceObject.resolveEffectBffModuleHandler)(mod, {
+                    openapi: effectConfig?.openapi,
+                    dataPlatform: effectConfig?.dataPlatform,
+                    validateRequest: (request)=>{
+                        const { path: mountedPathname } = (0, effect_namespaceObject.useEffectContext)();
+                        const prefix = matchingPrefixes.find((item)=>'/' === item || mountedPathname === item || mountedPathname.startsWith(`${item}/`));
+                        if (!prefix) return null;
+                        const requestUrl = new URL(request.url);
+                        if ('/' !== prefix) requestUrl.pathname = '/' === requestUrl.pathname ? prefix : `${prefix}${requestUrl.pathname}`;
+                        return (0, evaluation_js_namespaceObject.checkCrossProjectPolicyForRequest)(new Request(requestUrl, request), crossProjectPolicies.get(prefix));
+                    },
+                    onWarning: (message)=>utils_namespaceObject.logger.warn(message)
+                });
+                if (!loaded) {
+                    const error = new Error(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
+                    utils_namespaceObject.logger.warn(error.message);
+                    throw error;
+                }
+                const candidateOwner = {};
+                if (loaded.dispose) (0, runtime_lifecycle_namespaceObject.registerServerRuntimeDisposer)(candidateOwner, loaded.dispose);
+                const candidate = (0, runtime_lifecycle_namespaceObject.createDisposableServerRuntimeHandle)(candidateOwner, loaded.handler);
+                if (retired) {
+                    await candidate.dispose();
+                    throw new Error('Cannot initialize a retired Effect server.');
+                }
+                handler = candidate;
+            };
+            api.onPrepare(async ()=>{
+                const { middlewares: globalMiddlewares } = api.getServerContext();
+                const configuredPrefix = api.getServerConfig()?.bff?.prefix;
+                const enableHandleWeb = api.getServerConfig()?.bff?.enableHandleWeb;
+                const configuredPrefixes = Array.isArray(configuredPrefix) ? configuredPrefix.filter(Boolean) : [
+                    configuredPrefix || '/api'
+                ];
+                prefixes = [
+                    ...new Set(configuredPrefixes.length > 0 ? configuredPrefixes : [
+                        '/api'
+                    ])
+                ];
+                matchingPrefixes = [
+                    ...prefixes
+                ].sort((left, right)=>right.length - left.length);
+                prefix = prefixes[0] || '/api';
+                const { serverBase } = api.getServerContext();
+                if (serverBase) unregisterRuntimeDisposer = (0, runtime_lifecycle_namespaceObject.registerServerRuntimeDisposer)(serverBase, dispose);
+                try {
+                    await loadHandler();
+                } catch (error) {
+                    await dispose();
+                    throw error;
+                }
+                const middlewarePrefixes = enableHandleWeb ? [
+                    prefix
+                ] : matchingPrefixes;
+                const middlewares = middlewarePrefixes.map((middlewarePrefix)=>({
+                        name: 'effect-api-handler',
+                        path: enableHandleWeb ? '*' : `${middlewarePrefix}/*`,
+                        method: 'all',
+                        order: 'post',
+                        before: EFFECT_MIDDLEWARE_BEFORE,
+                        handler: async (context, next)=>{
+                            const activeHandler = handler;
+                            if (!activeHandler) {
+                                if (enableHandleWeb) return void await next();
+                                return (0, external_error_response_js_namespaceObject.createEffectServerRuntimeErrorResponse)(api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), context);
+                            }
+                            const mountedPrefix = enableHandleWeb ? matchingPrefixes.find((item)=>'/' === item || context.req.path === item || context.req.path.startsWith(`${item}/`)) || prefix : middlewarePrefix;
+                            const response = await (0, effect_namespaceObject.dispatchEffectBffRequest)(activeHandler, context.req.raw, {
+                                prefix: mountedPrefix,
+                                env: context.env,
+                                path: context.req.path,
+                                method: context.req.method,
+                                onError: (error)=>(0, external_error_response_js_namespaceObject.createEffectServerRuntimeErrorResponse)(api, error, context)
+                            });
+                            if (404 === response.status && enableHandleWeb) return void await next();
+                            return new Response(response.body, response);
+                        }
+                    }));
+                globalMiddlewares.push(...middlewares);
+            });
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/cjs/{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,23 +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,
-    generateEffectClientCode: ()=>external_worker_runtime_wrapper_js_namespaceObject.generateEffectClientCode,
+    bundleEffectWorkerRuntimeSource: ()=>external_worker_runtime_source_js_namespaceObject.bundleEffectWorkerRuntimeSource,
     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.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
+exports.bundleEffectWorkerRuntimeSource = __webpack_exports__.bundleEffectWorkerRuntimeSource;
 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",
-    "generateEffectClientCode",
+    "bundleEffectWorkerRuntimeSource",
     "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/loader.js

@@ -93,16 +93,18 @@ function preserveSourceModuleSemantics() {
         name: 'modern-js-effect-source-semantics',
         setup (buildApi) {
             buildApi.onLoad({
-                filter: /\.[cm]?[jt]sx?$/
+                filter: /\.[cm]?[jt]sx?$/,
+                namespace: 'file'
             }, async (args)=>{
                 const loader = sourceLoader(args);
                 if (!loader) return;
                 const source = await external_node_fs_default().promises.readFile(args.path, 'utf8');
+                const canonicalSourcePath = await external_node_fs_default().promises.realpath(args.path);
                 const compiled = await (0, external_esbuild_namespaceObject.transform)(source, {
                     define: {
-                        __dirname: JSON.stringify(external_node_path_default().dirname(args.path)),
-                        __filename: JSON.stringify(args.path),
-                        'import.meta.url': JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(args.path).href)
+                        __dirname: JSON.stringify(external_node_path_default().dirname(canonicalSourcePath)),
+                        __filename: JSON.stringify(canonicalSourcePath),
+                        'import.meta.url': JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(canonicalSourcePath).href)
                     },
                     jsx: 'automatic',
                     loader,
@@ -123,6 +125,7 @@ const nodeBuiltins = new Set([
     ...external_node_module_namespaceObject.builtinModules.map((name)=>`node:${name}`)
 ]);
 const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+const BFF_RUNTIME_PACKAGE = /^@modern-js\/(?:bff-effect|plugin-bff)(?:\/|$)/;
 async function isEsmOnlyFile(filename) {
     const extension = external_node_path_default().extname(filename).toLowerCase();
     if ('.mjs' === extension || '.mts' === extension) return true;
@@ -145,13 +148,16 @@ function isBareSpecifier(specifier) {
     return !specifier.startsWith('.') && !specifier.startsWith('/') && !external_node_path_default().isAbsolute(specifier);
 }
 function externalizeInstalledDependencies(options) {
-    const runtimeRequire = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(options.runtimeResolveDir, '__modern_effect_entry.cjs'));
     return {
         name: 'modern-js-effect-installed-dependencies',
         setup (buildApi) {
             buildApi.onResolve({
                 filter: /.*/
             }, async (args)=>{
+                if (BFF_RUNTIME_PACKAGE.test(args.path)) return {
+                    external: true,
+                    path: args.path
+                };
                 if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
                     external: true,
                     path: args.path
@@ -175,7 +181,8 @@ function externalizeInstalledDependencies(options) {
                     path: args.path
                 };
                 const realPath = await external_node_fs_default().promises.realpath(resolution.path).catch(()=>resolution.path);
-                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`)) {
+                const loader = SOURCE_LOADERS.get(external_node_path_default().extname(realPath).toLowerCase());
+                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`) && 'ts' !== loader && 'tsx' !== loader && 'jsx' !== loader) {
                     const runtimeResolution = await buildApi.resolve(args.path, {
                         importer: '',
                         kind: args.kind,
@@ -185,28 +192,10 @@ function externalizeInstalledDependencies(options) {
                         },
                         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
-                        };
-                    }
+                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) return {
+                        external: true,
+                        path: args.path
+                    };
                 }
                 return {
                     namespace: resolution.namespace,
@@ -234,7 +223,6 @@ async function bundleEffectEntryForNode(options) {
         platform: 'node',
         plugins: [
             externalizeInstalledDependencies({
-                format: options.format,
                 runtimeResolveDir: options.appDir
             }),
             preserveSourceModuleSemantics()
@@ -308,7 +296,6 @@ async function loadEffectSourceModule(options) {
         platform: 'node',
         plugins: [
             externalizeInstalledDependencies({
-                format: 'esm',
                 runtimeResolveDir: appDir
             }),
             preserveSourceModuleSemantics()

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

@@ -0,0 +1,60 @@
+"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");
+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);
+    return (0, node_namespaceObject.buildOperationContractMap)({
+        handlers: (0, effect_namespaceObject.toOperationContractSources)(endpoints),
+        ...(0, node_namespaceObject.resolveOperationProducer)({
+            directories: [
+                utils_namespaceObject.upath.dirname(options.resourcePath),
+                options.appDir
+            ],
+            requestId: options.requestId,
+            onDependency: options.onDependency
+        })
+    });
+}
+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/paths.js

@@ -0,0 +1,90 @@
+"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__, {
+    emittedEffectEntry: ()=>emittedEffectEntry,
+    relativeEffectAppPath: ()=>relativeEffectAppPath,
+    resolveEffectEntry: ()=>resolveEffectEntry,
+    resolveEffectEntryFile: ()=>resolveEffectEntryFile
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+const emittedEffectEntry = (entry)=>entry.replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
+function relativeEffectAppPath(appDir, entry) {
+    const relative = utils_namespaceObject.upath.relative(appDir, entry);
+    return '..' === relative || relative.startsWith('../') || relative.split('/').includes('node_modules') ? void 0 : relative;
+}
+function existingEntry(entry) {
+    return utils_namespaceObject.upath.extname(entry) ? utils_namespaceObject.fs.existsSync(entry) ? entry : void 0 : (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entry}${ext}`)) || void 0;
+}
+function resolveEffectEntry(options) {
+    const { appDir, apiDir, effectEntry, distDir } = options;
+    const entry = utils_namespaceObject.upath.resolve(appDir, effectEntry || utils_namespaceObject.upath.join(apiDir, 'index'));
+    if (distDir && void 0 !== relativeEffectAppPath(distDir, entry)) return {
+        kind: 'built-output',
+        path: existingEntry(emittedEffectEntry(entry))
+    };
+    const relative = relativeEffectAppPath(appDir, entry);
+    if (void 0 === relative) return {
+        kind: 'external-sdk',
+        path: existingEntry(entry)
+    };
+    return distDir ? {
+        kind: 'built-output',
+        path: existingEntry(emittedEffectEntry(utils_namespaceObject.upath.resolve(distDir, relative)))
+    } : {
+        kind: 'app-source',
+        path: existingEntry(entry)
+    };
+}
+function resolveEffectEntryFile(options) {
+    return resolveEffectEntry(options).path;
+}
+exports.emittedEffectEntry = __webpack_exports__.emittedEffectEntry;
+exports.relativeEffectAppPath = __webpack_exports__.relativeEffectAppPath;
+exports.resolveEffectEntry = __webpack_exports__.resolveEffectEntry;
+exports.resolveEffectEntryFile = __webpack_exports__.resolveEffectEntryFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "emittedEffectEntry",
+    "relativeEffectAppPath",
+    "resolveEffectEntry",
+    "resolveEffectEntryFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,73 @@
+"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__, {
+    default: ()=>loader
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_index_js_namespaceObject = require("./index.js");
+async function loader(source) {
+    this.cacheable();
+    delete require.cache[this.resourcePath];
+    const callback = this.async();
+    try {
+        const options = this.getOptions();
+        const entry = (0, external_index_js_namespaceObject.resolveEffectEntryFile)(options);
+        if (!entry || (0, external_node_fs_namespaceObject.realpathSync)(entry) !== (0, external_node_fs_namespaceObject.realpathSync)(this.resourcePath)) throw new Error(`Unexpected Effect BFF loader resource: ${this.resourcePath}`);
+        const query = new URLSearchParams(this.resourceQuery);
+        if (query.has('modern-bff-runtime-source')) {
+            const { transform } = await import("@swc/core");
+            const transformed = await transform(source, {
+                filename: this.resourcePath,
+                sourceMaps: false,
+                jsc: {
+                    parser: {
+                        syntax: "typescript",
+                        tsx: /\.[jt]sx$/.test(this.resourcePath)
+                    },
+                    target: 'es2024'
+                },
+                module: {
+                    type: 'es6'
+                }
+            });
+            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 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)));
+    }
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});