@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.0

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

@@ -0,0 +1,608 @@
+"use strict";
+var __webpack_modules__ = {
+    "../data-platform" (module) {
+        module.exports = require("../data-platform/index.js");
+    },
+    "./context" (module) {
+        module.exports = require("./context.js");
+    },
+    "@effect/opentelemetry" (module) {
+        module.exports = require("@effect/opentelemetry");
+    },
+    "effect/Config" (module) {
+        module.exports = require("effect/Config");
+    },
+    "effect/Effect" (module) {
+        module.exports = require("effect/Effect");
+    },
+    "effect/Layer" (module) {
+        module.exports = require("effect/Layer");
+    },
+    "effect/Option" (module) {
+        module.exports = require("effect/Option");
+    },
+    "effect/Schema" (module) {
+        module.exports = require("effect/Schema");
+    },
+    "effect/unstable/http" (module) {
+        module.exports = require("effect/unstable/http");
+    },
+    "effect/unstable/httpapi" (module) {
+        module.exports = require("effect/unstable/httpapi");
+    },
+    "effect/unstable/rpc" (module) {
+        module.exports = require("effect/unstable/rpc");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+        Config: ()=>effect_Config__rspack_import_6,
+        Effect: ()=>effect_Effect__rspack_import_7,
+        HttpApiBuilder: ()=>effect_unstable_httpapi__rspack_import_2.HttpApiBuilder,
+        HttpTraceContext: ()=>effect_unstable_http__rspack_import_1.HttpTraceContext,
+        Layer: ()=>effect_Layer__rspack_import_0,
+        OpenTelemetry: ()=>_effect_opentelemetry__rspack_import_5,
+        Option: ()=>effect_Option__rspack_import_8,
+        Schema: ()=>effect_Schema__rspack_import_9,
+        createHttpApiHandler: ()=>createHttpApiHandler,
+        defineEffectBff: ()=>defineEffectBff,
+        defineEffectRpcBff: ()=>defineEffectRpcBff,
+        useEffectContext: ()=>_context__rspack_import_10.useEffectContext
+    });
+    var effect_Layer__rspack_import_0 = __webpack_require__("effect/Layer");
+    var effect_unstable_http__rspack_import_1 = __webpack_require__("effect/unstable/http");
+    var effect_unstable_httpapi__rspack_import_2 = __webpack_require__("effect/unstable/httpapi");
+    var effect_unstable_rpc__rspack_import_3 = __webpack_require__("effect/unstable/rpc");
+    var _data_platform__rspack_import_4 = __webpack_require__("../data-platform");
+    var _effect_opentelemetry__rspack_import_5 = __webpack_require__("@effect/opentelemetry");
+    var effect_Config__rspack_import_6 = __webpack_require__("effect/Config");
+    var effect_Effect__rspack_import_7 = __webpack_require__("effect/Effect");
+    var effect_Option__rspack_import_8 = __webpack_require__("effect/Option");
+    var effect_Schema__rspack_import_9 = __webpack_require__("effect/Schema");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in effect_unstable_http__rspack_import_1)if ([
+        "Config",
+        "Layer",
+        "Schema",
+        "HttpTraceContext",
+        "HttpApiBuilder",
+        "useEffectContext",
+        "defineEffectBff",
+        "Effect",
+        "default",
+        "defineEffectRpcBff",
+        "createHttpApiHandler",
+        "OpenTelemetry",
+        "Option"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_http__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in effect_unstable_httpapi__rspack_import_2)if ([
+        "Config",
+        "Layer",
+        "Schema",
+        "HttpTraceContext",
+        "HttpApiBuilder",
+        "useEffectContext",
+        "defineEffectBff",
+        "Effect",
+        "default",
+        "defineEffectRpcBff",
+        "createHttpApiHandler",
+        "OpenTelemetry",
+        "Option"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_httpapi__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in effect_unstable_rpc__rspack_import_3)if ([
+        "Config",
+        "Layer",
+        "Schema",
+        "HttpTraceContext",
+        "HttpApiBuilder",
+        "useEffectContext",
+        "defineEffectBff",
+        "Effect",
+        "default",
+        "defineEffectRpcBff",
+        "createHttpApiHandler",
+        "OpenTelemetry",
+        "Option"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_rpc__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _context__rspack_import_10 = __webpack_require__("./context");
+    function normalizeOpenApiPath(pathname) {
+        if (!pathname.startsWith('/')) return `/${pathname}`;
+        return pathname;
+    }
+    function getOpenApiOptions(openapi) {
+        if (!openapi || 'object' != typeof openapi) return;
+        if (!openapi.path) return;
+        return {
+            path: normalizeOpenApiPath(openapi.path)
+        };
+    }
+    function normalizeRpcPath(pathname) {
+        if (!pathname || '/' === pathname) return '/rpc';
+        if (!pathname.startsWith('/')) return `/${pathname}`;
+        return pathname;
+    }
+    function normalizeBatchPath(pathname) {
+        if (!pathname || '/' === pathname) return _data_platform__rspack_import_4.DEFAULT_DATA_BATCH_ENDPOINT;
+        if (!pathname.startsWith('/')) return `/${pathname}`;
+        return pathname;
+    }
+    function isPlainObject(value) {
+        return 'object' == typeof value && null !== value && !Array.isArray(value);
+    }
+    function toTextLength(value) {
+        if ("u" > typeof TextEncoder) return new TextEncoder().encode(value).length;
+        if ("u" > typeof Buffer) return Buffer.byteLength(value);
+        return value.length;
+    }
+    function toHeaderRecord(headers) {
+        const record = {};
+        headers.forEach((value, key)=>{
+            record[key] = value;
+        });
+        return record;
+    }
+    function normalizeItemMethod(method) {
+        return (method || 'GET').toUpperCase();
+    }
+    function normalizeBatchAllowedMethods(allowedMethods) {
+        const source = Array.isArray(allowedMethods) && allowedMethods.length > 0 ? allowedMethods : [
+            'GET'
+        ];
+        return new Set(source.map((method)=>method.toUpperCase()));
+    }
+    function isBatchRequestPayload(value) {
+        return isPlainObject(value) && 1 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.sentAt && Array.isArray(value.items);
+    }
+    function createBatchValidationResponse(message, status = 400) {
+        return new Response(JSON.stringify({
+            message
+        }), {
+            status,
+            headers: {
+                'content-type': 'application/json; charset=utf-8'
+            }
+        });
+    }
+    function toBatchItemError(id, status, message) {
+        return {
+            id,
+            status,
+            headers: {
+                'content-type': 'application/json; charset=utf-8'
+            },
+            body: JSON.stringify({
+                message
+            })
+        };
+    }
+    function promiseWithTimeout(effect, timeoutMs) {
+        if (timeoutMs <= 0) return effect;
+        return new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                reject(new Error(`Batch item timeout after ${String(timeoutMs)}ms`));
+            }, timeoutMs);
+            effect.then((value)=>{
+                clearTimeout(timer);
+                resolve(value);
+            }, (error)=>{
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    async function mapWithConcurrency(items, concurrency, mapper) {
+        if (0 === items.length) return [];
+        const normalizedConcurrency = Math.max(1, concurrency);
+        const output = new Array(items.length);
+        let index = 0;
+        const workers = Array.from({
+            length: Math.min(normalizedConcurrency, items.length)
+        }, async ()=>{
+            while(true){
+                const currentIndex = index;
+                index += 1;
+                if (currentIndex >= items.length) return;
+                output[currentIndex] = await mapper(items[currentIndex], currentIndex);
+            }
+        });
+        await Promise.all(workers);
+        return output;
+    }
+    function getRequestPathname(request) {
+        try {
+            return new URL(request.url).pathname;
+        } catch  {
+            return new URL(request.url, 'http://localhost').pathname;
+        }
+    }
+    function normalizeMountPrefix(prefix) {
+        if (!prefix || '/' === prefix) return '';
+        return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    }
+    function getMountedPrefixFromContext(request, context) {
+        if (!isPlainObject(context) || 'string' != typeof context.path) return '';
+        const contextPath = normalizeMountPrefix(context.path);
+        const requestPath = normalizeMountPrefix(getRequestPathname(request));
+        if (!contextPath || !requestPath || contextPath === requestPath || !contextPath.endsWith(requestPath)) return '';
+        return normalizeMountPrefix(contextPath.slice(0, contextPath.length - requestPath.length));
+    }
+    function removeMountedPrefixFromBatchPath(pathWithQuery, prefix) {
+        const normalizedPrefix = normalizeMountPrefix(prefix);
+        if (!normalizedPrefix) return pathWithQuery;
+        const [pathname, ...queryParts] = pathWithQuery.split('?');
+        if (!pathname) return pathWithQuery;
+        let nextPathname = pathname;
+        if (pathname === normalizedPrefix) nextPathname = '/';
+        else if (pathname.startsWith(`${normalizedPrefix}/`)) {
+            const sliced = pathname.slice(normalizedPrefix.length);
+            nextPathname = sliced.startsWith('/') ? sliced : `/${sliced}`;
+        }
+        if (0 === queryParts.length) return nextPathname;
+        return `${nextPathname}?${queryParts.join('?')}`;
+    }
+    function getRequestOrigin(request) {
+        try {
+            return new URL(request.url).origin;
+        } catch  {
+            return new URL(request.url, 'http://localhost').origin;
+        }
+    }
+    function getExpectedEnvelopeOrigin(request) {
+        const origin = request.headers.get('origin');
+        if (origin && 'null' !== origin) return origin;
+        return getRequestOrigin(request);
+    }
+    function isRpcRequest(request, rpcPath) {
+        const pathname = getRequestPathname(request);
+        return pathname === rpcPath || pathname.startsWith(`${rpcPath}/`);
+    }
+    function getRpcSerializationLayer(serialization) {
+        switch(serialization){
+            case 'ndjson':
+                return effect_unstable_rpc__rspack_import_3.RpcSerialization.layerNdjson;
+            case 'jsonRpc':
+                return effect_unstable_rpc__rspack_import_3.RpcSerialization.layerJsonRpc();
+            case 'ndJsonRpc':
+                return effect_unstable_rpc__rspack_import_3.RpcSerialization.layerNdJsonRpc();
+            case 'msgPack':
+                return effect_unstable_rpc__rspack_import_3.RpcSerialization.layerMsgPack;
+            default:
+                return effect_unstable_rpc__rspack_import_3.RpcSerialization.layerJsonRpc();
+        }
+    }
+    function createRpcApiHandler(options) {
+        const rpcPath = normalizeRpcPath(options.path);
+        const rpcLayer = effect_Layer__rspack_import_0.provide(effect_unstable_rpc__rspack_import_3.RpcServer.layerHttp({
+            group: options.group,
+            path: rpcPath,
+            protocol: 'http',
+            disableTracing: options.disableTracing,
+            spanPrefix: options.spanPrefix,
+            spanAttributes: options.spanAttributes
+        }), effect_Layer__rspack_import_0.mergeAll(options.layer, getRpcSerializationLayer(options.serialization)));
+        return effect_unstable_http__rspack_import_1.HttpRouter.toWebHandler(rpcLayer);
+    }
+    function createOpenApiLayer(api, openapi) {
+        const openApiOptions = getOpenApiOptions(openapi);
+        if (!openApiOptions) return null;
+        return effect_unstable_http__rspack_import_1.HttpRouter.add('GET', openApiOptions.path, effect_unstable_http__rspack_import_1.HttpServerResponse.jsonUnsafe(effect_unstable_httpapi__rspack_import_2.OpenApi.fromApi(api)));
+    }
+    function createInvalidEnvelopeResponse(message, errors) {
+        return new Response(JSON.stringify({
+            message,
+            ...errors && errors.length > 0 ? {
+                errors
+            } : {}
+        }), {
+            status: 400,
+            headers: {
+                'content-type': 'application/json; charset=utf-8'
+            }
+        });
+    }
+    function validateDataPlatformRequestEnvelope(request, options) {
+        const isEnabled = options?.enabled ?? true;
+        if (!isEnabled) return null;
+        const envelopeHeader = options?.envelopeHeader || _data_platform__rspack_import_4.DEFAULT_DATA_ENVELOPE_HEADER;
+        const encodedEnvelope = request.headers.get(envelopeHeader);
+        if (!encodedEnvelope) {
+            if (options?.requireEnvelope) return createInvalidEnvelopeResponse(`Missing required data envelope header: ${envelopeHeader}`);
+            return null;
+        }
+        const envelope = (0, _data_platform__rspack_import_4.decodeRequestEnvelopeHeader)(encodedEnvelope);
+        if (!envelope) return createInvalidEnvelopeResponse(`Invalid data envelope header format: ${envelopeHeader}`);
+        const validation = (0, _data_platform__rspack_import_4.validateRequestEnvelope)(envelope, {
+            expectedProtocolVersion: 1,
+            expectedNamespace: options?.expectedNamespace,
+            expectedOrigin: options?.validateOrigin === false ? void 0 : getExpectedEnvelopeOrigin(request),
+            requireTraceContext: options?.requireTraceContext
+        });
+        if (!validation.ok) return createInvalidEnvelopeResponse('Invalid data envelope', validation.errors);
+        if (envelope.selectionPlan) {
+            const selectionValidation = (0, _data_platform__rspack_import_4.validateSelectionPlan)(envelope.selectionPlan, {
+                maxDepth: options?.selection?.maxDepth,
+                maxFields: options?.selection?.maxFields,
+                allowedLeafPaths: options?.selection?.allowedLeafPaths
+            });
+            if (!selectionValidation.ok) return createInvalidEnvelopeResponse('Invalid data envelope selection plan', selectionValidation.errors);
+        }
+        return null;
+    }
+    function mergeDataPlatformOptions(base, override) {
+        if (!base && !override) return;
+        const baseSelection = base?.selection;
+        const overrideSelection = override?.selection;
+        const baseBatch = base?.batch;
+        const overrideBatch = override?.batch;
+        return {
+            ...base,
+            ...override,
+            selection: baseSelection || overrideSelection ? {
+                ...baseSelection,
+                ...overrideSelection
+            } : void 0,
+            batch: baseBatch || overrideBatch ? {
+                ...baseBatch,
+                ...overrideBatch
+            } : void 0
+        };
+    }
+    function defineEffectBff(definition) {
+        const createHandler = (options)=>{
+            const rpcDefinition = definition.rpc;
+            let mergedRpcOptions = rpcDefinition;
+            if (rpcDefinition && options?.rpc) mergedRpcOptions = {
+                ...rpcDefinition,
+                ...options.rpc
+            };
+            return createHttpApiHandler({
+                api: definition.api,
+                layer: definition.layer,
+                openapi: options?.openapi,
+                rpc: mergedRpcOptions,
+                dataPlatform: mergeDataPlatformOptions(definition.dataPlatform, options?.dataPlatform)
+            });
+        };
+        const client = void 0;
+        return {
+            ...definition,
+            createHandler,
+            client
+        };
+    }
+    function defineEffectRpcBff(definition) {
+        const createHandler = (options)=>createRpcApiHandler({
+                ...definition,
+                ...options
+            });
+        return {
+            ...definition,
+            createHandler
+        };
+    }
+    function createHttpApiHandler(options) {
+        const apiLayer = options.layer;
+        const openApiLayer = createOpenApiLayer(options.api, options.openapi);
+        const mergedLayer = openApiLayer ? effect_Layer__rspack_import_0.mergeAll(apiLayer, openApiLayer) : apiLayer;
+        const httpApiHandler = effect_unstable_http__rspack_import_1.HttpRouter.toWebHandler(mergedLayer);
+        const dataPlatformBatchOptions = options.dataPlatform?.batch;
+        const batchEnabled = dataPlatformBatchOptions?.enabled !== false;
+        const batchPath = normalizeBatchPath(dataPlatformBatchOptions?.endpoint);
+        const batchMaxSize = Math.max(1, dataPlatformBatchOptions?.maxBatchSize ?? 16);
+        const batchMaxBytes = Math.max(1024, dataPlatformBatchOptions?.maxBatchBytes ?? 65536);
+        const batchConcurrency = Math.max(1, dataPlatformBatchOptions?.maxConcurrency ?? 4);
+        const batchItemTimeoutMs = Math.max(0, dataPlatformBatchOptions?.requestTimeoutMs ?? 10000);
+        const batchAllowedMethods = normalizeBatchAllowedMethods(dataPlatformBatchOptions?.allowedMethods);
+        const envelopeHeader = options.dataPlatform?.envelopeHeader || _data_platform__rspack_import_4.DEFAULT_DATA_ENVELOPE_HEADER;
+        const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
+        const withDataPlatformValidation = async (request, context)=>{
+            const validationError = validateDataPlatformRequestEnvelope(request, options.dataPlatform);
+            if (validationError) return validationError;
+            return httpApiHandler.handler(request, context);
+        };
+        const handleBatchRequest = async (request, context)=>{
+            const mountedPrefix = getMountedPrefixFromContext(request, context);
+            const method = normalizeItemMethod(request.method);
+            if ('POST' !== method) return createBatchValidationResponse('Batch endpoint only supports POST requests', 405);
+            const contentType = request.headers.get('content-type') || '';
+            if (!contentType.includes('application/json')) return createBatchValidationResponse('Batch endpoint requires application/json content-type', 415);
+            const payloadText = await request.text();
+            if (toTextLength(payloadText) > batchMaxBytes) return createBatchValidationResponse(`Batch payload exceeds max size (${String(batchMaxBytes)} bytes)`, 413);
+            let payload;
+            try {
+                payload = JSON.parse(payloadText);
+            } catch  {
+                return createBatchValidationResponse('Invalid batch payload JSON');
+            }
+            if (!isBatchRequestPayload(payload)) return createBatchValidationResponse('Invalid batch payload shape');
+            if (0 === payload.items.length) return createBatchValidationResponse('Batch payload items cannot be empty');
+            if (payload.items.length > batchMaxSize) return createBatchValidationResponse(`Batch item count exceeds max size (${String(batchMaxSize)})`, 413);
+            const responseItems = await mapWithConcurrency(payload.items, batchConcurrency, async (rawItem, index)=>{
+                const fallbackId = `item_${String(index)}`;
+                const itemId = isPlainObject(rawItem) && 'string' == typeof rawItem.id ? rawItem.id : fallbackId;
+                if (!isPlainObject(rawItem)) return toBatchItemError(itemId, 400, 'Invalid batch item; expected object');
+                if ('string' != typeof rawItem.path || 0 === rawItem.path.length) return toBatchItemError(itemId, 400, 'Invalid batch item path');
+                if (!rawItem.path.startsWith('/')) return toBatchItemError(itemId, 400, 'Batch item path must start with "/"');
+                const normalizedItemPath = removeMountedPrefixFromBatchPath(rawItem.path, mountedPrefix);
+                const itemPathname = normalizedItemPath.split('?')[0] || normalizedItemPath;
+                if (itemPathname === batchPath || itemPathname.startsWith(`${batchPath}/`)) return toBatchItemError(itemId, 400, 'Batch item path cannot target batch endpoint');
+                const itemMethod = normalizeItemMethod('string' == typeof rawItem.method ? rawItem.method : void 0);
+                if (!batchAllowedMethods.has(itemMethod)) return toBatchItemError(itemId, 405, `Batch item method ${itemMethod} is not allowed`);
+                if (void 0 !== rawItem.body && null !== rawItem.body && 'string' != typeof rawItem.body) return toBatchItemError(itemId, 400, 'Batch item body must be a string when provided');
+                if (('GET' === itemMethod || 'HEAD' === itemMethod) && 'string' == typeof rawItem.body) return toBatchItemError(itemId, 400, `${itemMethod} batch item cannot include body`);
+                const normalizedHeaders = {};
+                if (void 0 !== rawItem.headers) {
+                    if (!isPlainObject(rawItem.headers)) return toBatchItemError(itemId, 400, 'Batch item headers must be an object');
+                    for (const [key, value] of Object.entries(rawItem.headers)){
+                        if ('string' != typeof value) return toBatchItemError(itemId, 400, `Invalid header "${key}" for batch item`);
+                        normalizedHeaders[key.toLowerCase()] = value;
+                    }
+                }
+                if (!normalizedHeaders.traceparent) {
+                    const encodedEnvelope = normalizedHeaders[normalizedEnvelopeHeader];
+                    if ('string' == typeof encodedEnvelope) {
+                        const envelope = (0, _data_platform__rspack_import_4.decodeRequestEnvelopeHeader)(encodedEnvelope);
+                        if (envelope?.traceparent) normalizedHeaders.traceparent = envelope.traceparent;
+                    }
+                }
+                if (!normalizedHeaders.traceparent) {
+                    const requestTraceparent = request.headers.get('traceparent');
+                    if (requestTraceparent) normalizedHeaders.traceparent = requestTraceparent;
+                }
+                const targetUrl = new URL(normalizedItemPath, request.url);
+                const requestHeaders = new Headers(normalizedHeaders);
+                const body = 'GET' === itemMethod || 'HEAD' === itemMethod ? void 0 : rawItem.body;
+                if (void 0 === body) requestHeaders.delete('content-type');
+                const itemRequest = new Request(targetUrl.toString(), {
+                    method: itemMethod,
+                    headers: requestHeaders,
+                    body
+                });
+                try {
+                    const itemResponse = await promiseWithTimeout(withDataPlatformValidation(itemRequest, context), batchItemTimeoutMs);
+                    if (!(itemResponse instanceof Response)) return toBatchItemError(itemId, 500, 'Invalid response returned by batch item handler');
+                    const bodyText = await itemResponse.text();
+                    const responseItem = {
+                        id: itemId,
+                        status: itemResponse.status,
+                        headers: toHeaderRecord(itemResponse.headers),
+                        ...bodyText ? {
+                            body: bodyText
+                        } : {}
+                    };
+                    return responseItem;
+                } catch (error) {
+                    if (error instanceof Response) {
+                        const bodyText = await error.text();
+                        return {
+                            id: itemId,
+                            status: error.status,
+                            headers: toHeaderRecord(error.headers),
+                            ...bodyText ? {
+                                body: bodyText
+                            } : {}
+                        };
+                    }
+                    const message = error instanceof Error ? error.message : String(error);
+                    return toBatchItemError(itemId, 500, message);
+                }
+            });
+            const responsePayload = {
+                protocolVersion: 1,
+                batchId: payload.batchId,
+                receivedAt: Date.now(),
+                items: responseItems
+            };
+            return new Response(JSON.stringify(responsePayload), {
+                status: 200,
+                headers: {
+                    'content-type': 'application/json; charset=utf-8',
+                    [_data_platform__rspack_import_4.DEFAULT_DATA_BATCH_HEADER]: '1',
+                    'x-modernjs-data-batch-id': payload.batchId
+                }
+            });
+        };
+        const handleHttpApiRequest = async (request, context)=>{
+            const pathname = getRequestPathname(request);
+            if (batchEnabled && pathname === batchPath) return handleBatchRequest(request, context);
+            return withDataPlatformValidation(request, context);
+        };
+        if (!options.rpc) return {
+            handler: handleHttpApiRequest,
+            dispose: async ()=>{
+                await httpApiHandler.dispose();
+            }
+        };
+        const rpcPath = normalizeRpcPath(options.rpc.path);
+        const rpcHandler = createRpcApiHandler(options.rpc);
+        return {
+            handler: async (request, context)=>{
+                if (isRpcRequest(request, rpcPath)) return rpcHandler.handler(request, context);
+                return handleHttpApiRequest(request);
+            },
+            dispose: async ()=>{
+                await Promise.all([
+                    httpApiHandler.dispose(),
+                    rpcHandler.dispose()
+                ]);
+            }
+        };
+    }
+})();
+exports.Config = __webpack_exports__.Config;
+exports.Effect = __webpack_exports__.Effect;
+exports.HttpApiBuilder = __webpack_exports__.HttpApiBuilder;
+exports.HttpTraceContext = __webpack_exports__.HttpTraceContext;
+exports.Layer = __webpack_exports__.Layer;
+exports.OpenTelemetry = __webpack_exports__.OpenTelemetry;
+exports.Option = __webpack_exports__.Option;
+exports.Schema = __webpack_exports__.Schema;
+exports.createHttpApiHandler = __webpack_exports__.createHttpApiHandler;
+exports.defineEffectBff = __webpack_exports__.defineEffectBff;
+exports.defineEffectRpcBff = __webpack_exports__.defineEffectRpcBff;
+exports.useEffectContext = __webpack_exports__.useEffectContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Config",
+    "Effect",
+    "HttpApiBuilder",
+    "HttpTraceContext",
+    "Layer",
+    "OpenTelemetry",
+    "Option",
+    "Schema",
+    "createHttpApiHandler",
+    "defineEffectBff",
+    "defineEffectRpcBff",
+    "useEffectContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});