@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.9 → 3.2.0-ultramodern.90

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

@@ -0,0 +1,115 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    resolveEffectBffModuleHandler: ()=>resolveEffectBffModuleHandler
+});
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const external_handler_js_namespaceObject = require("./handler.js");
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+function includesRuntimeExports(value) {
+    return 'api' in value || 'layer' in value || 'createHandler' in value || 'handler' in value;
+}
+function isRequestHandler(value) {
+    return 'function' == typeof value;
+}
+function isEffectApiDefinition(module) {
+    return httpapi_namespaceObject.HttpApi.isHttpApi(module.api) && void 0 !== module.layer;
+}
+async function resolveEffectBffModuleHandler(mod, options = {}) {
+    let normalizedModule = mod;
+    const mergeRuntimeExports = (value)=>{
+        if (!isRecord(value) || !includesRuntimeExports(value)) return;
+        normalizedModule = {
+            ...normalizedModule,
+            ...value
+        };
+    };
+    if (isRequestHandler(normalizedModule.handler)) return {
+        handler: normalizedModule.handler
+    };
+    const entry = normalizedModule.default;
+    if (isRequestHandler(entry)) return {
+        handler: entry
+    };
+    if ('function' == typeof entry && 0 === entry.length) {
+        const out = await entry();
+        if (isRequestHandler(out)) return {
+            handler: out
+        };
+        mergeRuntimeExports(out);
+    }
+    if (isRecord(entry)) normalizedModule = {
+        ...normalizedModule,
+        ...entry
+    };
+    if (isRecord(entry) && 'handler' in entry) {
+        const maybeHandler = entry.handler;
+        if (isRequestHandler(maybeHandler)) normalizedModule = {
+            ...normalizedModule,
+            handler: maybeHandler
+        };
+    }
+    if (isRequestHandler(normalizedModule.handler)) return {
+        handler: normalizedModule.handler
+    };
+    if ('function' == typeof normalizedModule.createHandler) {
+        const webHandler = normalizedModule.createHandler({
+            openapi: options.openapi,
+            dataPlatform: options.dataPlatform
+        });
+        return {
+            handler: async (request, context)=>webHandler.handler(request, context),
+            dispose: async ()=>{
+                await webHandler.dispose();
+            }
+        };
+    }
+    if (isEffectApiDefinition(normalizedModule)) {
+        options.onWarning?.('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/plugin-bff/server to avoid module instance mismatch.');
+        const webHandler = (0, external_handler_js_namespaceObject.createHttpApiHandler)({
+            api: normalizedModule.api,
+            layer: normalizedModule.layer,
+            openapi: options.openapi,
+            dataPlatform: options.dataPlatform
+        });
+        return {
+            handler: async (request, context)=>webHandler.handler(request, context),
+            dispose: async ()=>{
+                await webHandler.dispose();
+            }
+        };
+    }
+    return null;
+}
+exports.resolveEffectBffModuleHandler = __webpack_exports__.resolveEffectBffModuleHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveEffectBffModuleHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/operation-context.js

@@ -0,0 +1,111 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    createEffectOperationContext: ()=>createEffectOperationContext
+});
+const create_request_namespaceObject = require("@modern-js/create-request");
+const TRACEPARENT_REGEX = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/i;
+const readHeader = (headers, header)=>{
+    const value = headers.get(header);
+    return value && value.length > 0 ? value : void 0;
+};
+const copyStringField = (target, details, key)=>{
+    const value = details[key];
+    if ('string' == typeof value && value.length > 0) target[key] = value;
+};
+const parseTraceparent = (traceparent)=>{
+    if (!traceparent) return;
+    const match = traceparent.trim().match(TRACEPARENT_REGEX);
+    if (!match) return;
+    const [, traceId, spanId] = match;
+    if (!traceId || !spanId) return;
+    return {
+        traceId: traceId.toLowerCase(),
+        spanId: spanId.toLowerCase()
+    };
+};
+const readOperationContextDetails = (request)=>{
+    const rawDetails = readHeader(request.headers, create_request_namespaceObject.BFF_OPERATION_CONTEXT_DETAIL_HEADER);
+    if (!rawDetails) return {};
+    try {
+        const parsed = JSON.parse(rawDetails);
+        if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) return {};
+        const details = parsed;
+        const safeDetails = {};
+        copyStringField(safeDetails, details, 'requestId');
+        copyStringField(safeDetails, details, 'operationId');
+        copyStringField(safeDetails, details, 'schemaHash');
+        copyStringField(safeDetails, details, 'traceparent');
+        copyStringField(safeDetails, details, 'traceId');
+        copyStringField(safeDetails, details, 'spanId');
+        if ('number' == typeof details.operationVersion) safeDetails.operationVersion = details.operationVersion;
+        return safeDetails;
+    } catch  {
+        return {};
+    }
+};
+const createEffectOperationContext = ({ request, path, method })=>{
+    const details = readOperationContextDetails(request);
+    const servicePath = new URL(request.url).pathname;
+    const traceparent = readHeader(request.headers, create_request_namespaceObject.BFF_TRACEPARENT_HEADER) || details.traceparent;
+    const parsedTraceparent = details.traceId && details.spanId ? {
+        traceId: details.traceId,
+        spanId: details.spanId
+    } : parseTraceparent(traceparent);
+    const locale = readHeader(request.headers, create_request_namespaceObject.BFF_LOCALE_HEADER);
+    const headerOperationId = readHeader(request.headers, create_request_namespaceObject.BFF_OPERATION_CONTEXT_HEADER);
+    return {
+        ...details,
+        ...headerOperationId || details.operationId ? {
+            operationId: headerOperationId || details.operationId
+        } : {},
+        routePath: servicePath,
+        method: (method || request.method || 'GET').toUpperCase(),
+        source: 'effect-adapter',
+        ...path && path !== servicePath ? {
+            attributes: {
+                mountedPath: path
+            }
+        } : {},
+        ...locale ? {
+            locale
+        } : {},
+        ...traceparent ? {
+            traceparent
+        } : {},
+        ...parsedTraceparent ? {
+            traceId: parsedTraceparent.traceId,
+            spanId: parsedTraceparent.spanId
+        } : {}
+    };
+};
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectOperationContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect-client/index.js

@@ -45,6 +45,7 @@ __webpack_require__.d(__webpack_exports__, {
     runEffectView: ()=>runEffectView,
     view: ()=>view
 });
+const create_request_namespaceObject = require("@modern-js/create-request");
 const Data_namespaceObject = require("effect/Data");
 const Effect_namespaceObject = require("effect/Effect");
 const Exit_namespaceObject = require("effect/Exit");
@@ -94,8 +95,19 @@ function getRpcSerializationLayer(serialization) {
     }
 }
 function makeEffectHttpApiClient(api, options) {
+    const requestContextHeaders = (0, create_request_namespaceObject.createRequestContextHeaders)(options?.requestContext);
+    const transformClient = (client)=>{
+        const contextClient = 0 === Object.keys(requestContextHeaders).length ? client : client.pipe(http_namespaceObject.HttpClient.mapRequest((request)=>{
+            let nextRequest = request;
+            for (const [header, value] of Object.entries(requestContextHeaders))if (void 0 === nextRequest.headers[header.toLowerCase()]) nextRequest = http_namespaceObject.HttpClientRequest.setHeader(nextRequest, header, value);
+            return nextRequest;
+        }));
+        return options?.transformClient ? options.transformClient(contextClient) : contextClient;
+    };
     return httpapi_namespaceObject.HttpApiClient.make(api, {
-        baseUrl: options?.baseUrl
+        baseUrl: options?.baseUrl,
+        transformClient,
+        transformResponse: options?.transformResponse
     }).pipe(Effect_namespaceObject.provide(http_namespaceObject.FetchHttpClient.layer));
 }
 function makeEffectRpcClient(group, options) {

package/dist/cjs/utils/effectClientGenerator.js

@@ -621,9 +621,26 @@ export type EffectOperationManifest = Record<
   string,
   Record<string, EffectOperationDescriptor>
 >;
+export type EffectOperationContext = {
+  requestId?: string;
+  operationId?: string;
+  routePath?: string;
+  method?: string;
+  schemaHash?: string;
+  operationVersion?: number;
+  locale?: string;
+  traceparent?: string;
+  traceId?: string;
+  spanId?: string;
+  source?: string;
+  scope?: Record<string, unknown>;
+  sessionClaims?: Record<string, unknown>;
+  attributes?: Record<string, unknown>;
+};
 export type EffectRequestContext = {
   headers?: Record<string, string>;
   locale?: string;
+  operationContext?: EffectOperationContext;
   traceparent?: string;
   traceId?: string;
   spanId?: string;

package/dist/esm/loader.mjs

@@ -2,6 +2,24 @@ import { generateClient } from "@modern-js/bff-core";
 import { logger } from "@modern-js/utils";
 import path from "path";
 import { generateEffectClientCode, resolveEffectEntryFile } from "./utils/effectClientGenerator.mjs";
+async function transformEffectRuntimeSource(source, filename) {
+    const swc = await import("@swc/core");
+    const result = await swc.transform(source, {
+        filename,
+        sourceMaps: false,
+        jsc: {
+            parser: {
+                syntax: "typescript",
+                tsx: filename.endsWith('.tsx') || filename.endsWith('.jsx')
+            },
+            target: 'es2022'
+        },
+        module: {
+            type: 'es6'
+        }
+    });
+    return result.code;
+}
 async function loader(source) {
     this.cacheable();
     const { resourcePath } = this;
@@ -13,6 +31,11 @@ async function loader(source) {
         apiDir: draftOptions.apiDir,
         effectEntry: draftOptions.effectEntry
     });
+    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath) && this.resourceQuery.includes('modern-bff-runtime')) {
+        const code = await transformEffectRuntimeSource(source, resourcePath);
+        callback(void 0, code);
+        return;
+    }
     if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath)) {
         const code = await generateEffectClientCode({
             appDir: draftOptions.appDir,

package/dist/esm/runtime/data-platform/index.mjs

@@ -1,3 +1,25 @@
+import { trace as api_trace } from "@opentelemetry/api";
+const DATA_BATCH_TRANSPORT_OTEL_EVENT = 'modernjs.data.batch';
+function createDataBatchTransportTelemetryAttributes(event) {
+    return {
+        'modernjs.data.batch.type': event.type,
+        'modernjs.data.batch.endpoint': event.endpoint,
+        'modernjs.data.batch.degraded': 'fallback' === event.type || 'disable' === event.type,
+        ...event.batchId ? {
+            'modernjs.data.batch.id': event.batchId
+        } : {},
+        ...'number' == typeof event.size ? {
+            'modernjs.data.batch.size': event.size
+        } : {},
+        ...event.reason ? {
+            'modernjs.data.batch.reason': event.reason
+        } : {}
+    };
+}
+function emitDataBatchTransportEvent(onEvent, event) {
+    onEvent?.(event);
+    api_trace.getActiveSpan()?.addEvent(DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes(event));
+}
 const DEFAULT_DATA_ENVELOPE_HEADER = 'x-modernjs-data-envelope';
 const DEFAULT_DATA_BATCH_ENDPOINT = '/_data/batch';
 const DEFAULT_DATA_BATCH_HEADER = 'x-modernjs-data-batch';
@@ -415,7 +437,7 @@ function createDataBatchTransport(options = {}) {
         bucket.items = [];
         bucket.bytes = 0;
         if (1 === items.length || disabledEndpoints.has(endpoint)) {
-            onEvent?.({
+            emitDataBatchTransportEvent(onEvent, {
                 type: disabledEndpoints.has(endpoint) ? 'fallback' : 'flush',
                 endpoint,
                 size: items.length,
@@ -432,7 +454,7 @@ function createDataBatchTransport(options = {}) {
             sentAt: Date.now(),
             items: items.map((item)=>item.item)
         };
-        onEvent?.({
+        emitDataBatchTransportEvent(onEvent, {
             type: 'flush',
             endpoint,
             batchId,
@@ -459,7 +481,7 @@ function createDataBatchTransport(options = {}) {
                 requestInit.signal = controller.signal;
                 timeoutHandle = setTimeout(()=>{
                     controller.abort();
-                    onEvent?.({
+                    emitDataBatchTransportEvent(onEvent, {
                         type: 'fallback',
                         endpoint,
                         batchId,
@@ -472,13 +494,13 @@ function createDataBatchTransport(options = {}) {
             if (!response.ok) {
                 if (404 === response.status || 405 === response.status) {
                     disabledEndpoints.add(endpoint);
-                    onEvent?.({
+                    emitDataBatchTransportEvent(onEvent, {
                         type: 'disable',
                         endpoint,
                         batchId,
                         reason: `batch-endpoint-unavailable-${String(response.status)}`
                     });
-                } else onEvent?.({
+                } else emitDataBatchTransportEvent(onEvent, {
                     type: 'fallback',
                     endpoint,
                     batchId,
@@ -491,7 +513,7 @@ function createDataBatchTransport(options = {}) {
             }
             const result = await response.json();
             if (!isBatchResponsePayload(result)) {
-                onEvent?.({
+                emitDataBatchTransportEvent(onEvent, {
                     type: 'fallback',
                     endpoint,
                     batchId,
@@ -514,7 +536,7 @@ function createDataBatchTransport(options = {}) {
                 return parseResponseLikeCreateRequest(reconstructedResponse);
             });
         } catch (error) {
-            onEvent?.({
+            emitDataBatchTransportEvent(onEvent, {
                 type: 'fallback',
                 endpoint,
                 batchId,
@@ -581,7 +603,7 @@ function createDataBatchTransport(options = {}) {
             };
             bucket.items.push(queued);
             bucket.bytes += size;
-            onEvent?.({
+            emitDataBatchTransportEvent(onEvent, {
                 type: 'enqueue',
                 endpoint,
                 size: bucket.items.length
@@ -596,4 +618,4 @@ function createDataBatchTransport(options = {}) {
         return promise;
     };
 }
-export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, buildQueryKey, buildScopeKey, createDataBatchTransport, createHydrationEnvelope, createInvalidationEvent, createOperationId, createRequestEnvelope, decodeRequestEnvelopeHeader, deriveChildTraceContext, encodeRequestEnvelopeHeader, formatTraceparentHeader, normalizeOrigin, parseTraceparentHeader, shouldApplyInvalidation, stableStringify, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan };
+export { DATA_BATCH_TRANSPORT_OTEL_EVENT, DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, buildQueryKey, buildScopeKey, createDataBatchTransport, createDataBatchTransportTelemetryAttributes, createHydrationEnvelope, createInvalidationEvent, createOperationId, createRequestEnvelope, decodeRequestEnvelopeHeader, deriveChildTraceContext, emitDataBatchTransportEvent, encodeRequestEnvelopeHeader, formatTraceparentHeader, normalizeOrigin, parseTraceparentHeader, shouldApplyInvalidation, stableStringify, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan };

package/dist/esm/runtime/effect/adapter.mjs

@@ -1,8 +1,7 @@
 import { API_DIR, compatibleRequire, findExists, fs, isProd, logger } from "@modern-js/utils";
-import { HttpApi } from "effect/unstable/httpapi";
 import path from "path";
-import { runWithEffectContext } from "./context.mjs";
-import { createHttpApiHandler } from "./index.mjs";
+import { createEffectOperationContext, runWithEffectContext } from "./context.mjs";
+import { resolveEffectBffModuleHandler } from "./module.mjs";
 const before = [
     'custom-server-hook',
     'custom-server-middleware',
@@ -35,24 +34,9 @@ function createRequestForMountedPrefix(req, prefix) {
     url.pathname = nextPath;
     return new Request(url, req);
 }
-function isRequestHandler(value) {
-    return 'function' == typeof value;
-}
 function maybeResponse(value) {
     return value instanceof Response;
 }
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function includesRuntimeExports(value) {
-    return 'api' in value || 'layer' in value || 'createHandler' in value || 'handler' in value;
-}
-function isHttpApiWithProps(value) {
-    return HttpApi.isHttpApi(value) && isRecord(value) && 'string' == typeof value.identifier && isRecord(value.groups);
-}
-function isEffectApiDefinition(module) {
-    return isHttpApiWithProps(module.api) && void 0 !== module.layer;
-}
 class EffectAdapter {
     resolveEntryFile() {
         const { appDirectory, apiDirectory } = this.api.getServerContext();
@@ -63,70 +47,13 @@ class EffectAdapter {
         return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
     }
     async loadEffectHandlerFromModule(mod) {
-        let normalizedModule = mod;
-        const mergeRuntimeExports = (value)=>{
-            if (!isRecord(value) || !includesRuntimeExports(value)) return;
-            normalizedModule = {
-                ...normalizedModule,
-                ...value
-            };
-        };
-        if (isRequestHandler(normalizedModule.handler)) return {
-            handler: normalizedModule.handler
-        };
-        const entry = normalizedModule.default;
-        if (isRequestHandler(entry)) return {
-            handler: entry
-        };
-        if ('function' == typeof entry && 0 === entry.length) {
-            const out = await entry();
-            if (isRequestHandler(out)) return {
-                handler: out
-            };
-            mergeRuntimeExports(out);
-        }
-        if (isRecord(entry)) normalizedModule = {
-            ...normalizedModule,
-            ...entry
-        };
-        if (isRecord(entry) && 'handler' in entry) {
-            const maybeHandler = entry.handler;
-            if (isRequestHandler(maybeHandler)) normalizedModule = {
-                ...normalizedModule,
-                handler: maybeHandler
-            };
-        }
-        if (isRequestHandler(normalizedModule.handler)) return {
-            handler: normalizedModule.handler
-        };
-        if ('function' == typeof normalizedModule.createHandler) {
-            const webHandler = normalizedModule.createHandler({
-                openapi: this.api.getServerConfig()?.bff?.effect?.openapi,
-                dataPlatform: this.api.getServerConfig()?.bff?.effect?.dataPlatform
-            });
-            return {
-                handler: async (request)=>webHandler.handler(request),
-                dispose: async ()=>{
-                    await webHandler.dispose();
-                }
-            };
-        }
-        if (isEffectApiDefinition(normalizedModule)) {
-            logger.warn('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/plugin-bff/server to avoid module instance mismatch.');
-            const webHandler = createHttpApiHandler({
-                api: normalizedModule.api,
-                layer: normalizedModule.layer,
-                openapi: this.api.getServerConfig()?.bff?.effect?.openapi,
-                dataPlatform: this.api.getServerConfig()?.bff?.effect?.dataPlatform
-            });
-            return {
-                handler: async (request)=>webHandler.handler(request),
-                dispose: async ()=>{
-                    await webHandler.dispose();
-                }
-            };
-        }
-        return null;
+        return resolveEffectBffModuleHandler(mod, {
+            openapi: this.api.getServerConfig()?.bff?.effect?.openapi,
+            dataPlatform: this.api.getServerConfig()?.bff?.effect?.dataPlatform,
+            onWarning: (message)=>{
+                logger.warn(message);
+            }
+        });
     }
     async reloadHandler() {
         if (!this.isEffect) return;
@@ -244,7 +171,13 @@ class EffectAdapter {
                             request: effectRequest,
                             env: c.env,
                             path: c.req.path,
-                            method: c.req.method
+                            method: c.req.method,
+                            operationContext: createEffectOperationContext({
+                                request: effectRequest,
+                                env: c.env,
+                                path: c.req.path,
+                                method: c.req.method
+                            })
                         };
                         response = await runWithEffectContext(effectContext, ()=>this.handler.length > 1 ? this.handler(effectRequest, effectContext) : this.handler(effectRequest));
                     } catch (error) {

package/dist/esm/runtime/effect/context.mjs

@@ -8,4 +8,6 @@ const useEffectContext = ()=>{
     if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
     return context;
 };
-export { runWithEffectContext, useEffectContext };
+const useOperationContext = ()=>useEffectContext().operationContext;
+export { createEffectOperationContext } from "./operation-context.mjs";
+export { runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm/runtime/effect/edge.mjs

@@ -0,0 +1,90 @@
+import { resolveEffectBffModuleHandler } from "./module.mjs";
+import { createEffectOperationContext } from "./operation-context.mjs";
+export * from "./handler.mjs";
+function normalizePrefix(prefix) {
+    if (!prefix || '/' === prefix) return '';
+    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+}
+function removePrefixFromPath(pathname, prefix) {
+    const normalized = normalizePrefix(prefix);
+    if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
+    const sliced = pathname.slice(normalized.length);
+    return sliced.startsWith('/') ? sliced : `/${sliced}`;
+}
+function matchesPrefix(pathname, prefix) {
+    const normalized = normalizePrefix(prefix);
+    return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function createRequestForMountedPrefix(req, prefix) {
+    const url = new URL(req.url);
+    const nextPath = removePrefixFromPath(url.pathname, prefix);
+    if (nextPath === url.pathname) return req;
+    url.pathname = nextPath;
+    return new Request(url, req);
+}
+function createEdgeEffectContext(originalRequest, effectRequest, options) {
+    const originalPath = options.path || new URL(originalRequest.url).pathname;
+    const method = options.method || originalRequest.method;
+    return {
+        request: effectRequest,
+        env: options.env || {},
+        path: originalPath,
+        method,
+        operationContext: createEffectOperationContext({
+            request: effectRequest,
+            env: options.env || {},
+            path: originalPath,
+            method
+        })
+    };
+}
+function createRuntimeErrorResponse(error) {
+    const status = 'object' == typeof error && null !== error && 'status' in error && 'number' == typeof error.status ? error.status : 500;
+    return new Response(JSON.stringify({
+        message: error instanceof Error ? error.message : '[BFF] Internal Server Error'
+    }), {
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8'
+        }
+    });
+}
+async function dispatchEffectBffRequest(handler, request, options = {}) {
+    const requestPathname = new URL(request.url).pathname;
+    if (!matchesPrefix(requestPathname, options.prefix)) return new Response(null, {
+        status: 404
+    });
+    const effectRequest = createRequestForMountedPrefix(request, options.prefix);
+    const effectContext = createEdgeEffectContext(request, effectRequest, options);
+    try {
+        const response = handler.length > 1 ? await handler(effectRequest, effectContext) : await handler(effectRequest);
+        if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return a Response instance.');
+        return new Response(response.body, response);
+    } catch (error) {
+        if (error instanceof Response) return new Response(error.body, error);
+        if (options.onError) {
+            const errorResponse = await options.onError(error, effectContext);
+            if (errorResponse instanceof Response) return errorResponse;
+        }
+        return createRuntimeErrorResponse(error);
+    }
+}
+async function createEffectBffEdgeHandler(options) {
+    const loaded = await resolveEffectBffModuleHandler(options.module, {
+        openapi: options.openapi,
+        dataPlatform: options.dataPlatform,
+        onWarning: options.onWarning
+    });
+    if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export { api, layer }, createHandler, or handler.');
+    return {
+        handler: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
+                ...dispatchOptions,
+                prefix: options.prefix,
+                onError: options.onError
+            }),
+        dispose: async ()=>{
+            await loaded.dispose?.();
+        }
+    };
+}
+export { createEffectBffEdgeHandler, createEffectOperationContext, dispatchEffectBffRequest };