@bleedingdev/modern-js-plugin-bff 3.8.3-ultramodern.1 → 3.8.3-ultramodern.3

package/dist/esm-node/runtime/effect/handler/batch.mjs

@@ -1,98 +0,0 @@
-import "node:module";
-import { DEFAULT_DATA_BATCH_ENDPOINT, isPlainObject, normalizeMethod } from "../../data-platform/index.mjs";
-function normalizeBatchPath(pathname) {
-    if (!pathname || '/' === pathname) return DEFAULT_DATA_BATCH_ENDPOINT;
-    if (!pathname.startsWith('/')) return `/${pathname}`;
-    return pathname;
-}
-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 cloneWithoutJsonBodyHeaders(request) {
-    const headers = new Headers(request.headers);
-    headers.delete('content-type');
-    headers.delete('content-length');
-    return new Request(request.url, {
-        method: request.method,
-        headers,
-        signal: request.signal
-    });
-}
-async function prepareJsonRequestBody(request) {
-    const method = normalizeMethod(request.method);
-    if ('GET' === method || 'HEAD' === method) return request;
-    const contentType = (request.headers.get('content-type') || '').toLowerCase();
-    if (!contentType.includes('application/json')) return request;
-    if (null === request.body) return cloneWithoutJsonBodyHeaders(request);
-    try {
-        const bodyText = await request.clone().text();
-        if ('' === bodyText) return cloneWithoutJsonBodyHeaders(request);
-        JSON.parse(bodyText);
-    } catch  {
-        return createBatchValidationResponse('Invalid JSON request body');
-    }
-    return request;
-}
-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;
-}
-export { toHeaderRecord } from "../../../utils/headers.mjs";
-export { createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchAllowedMethods, normalizeBatchPath, prepareJsonRequestBody, promiseWithTimeout, toBatchItemError };

package/dist/esm-node/runtime/effect/handler/definition.mjs

@@ -1,62 +0,0 @@
-import "node:module";
-import { EFFECT_VALIDATOR_AWARE_FACTORY } from "../entry-shape.mjs";
-import { mergeDataPlatformOptions } from "./envelope.mjs";
-import { createHttpApiHandler } from "./http.mjs";
-import { createRpcApiHandler } from "./rpc.mjs";
-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),
-            interceptRequest: definition.interceptRequest,
-            validateRequest: options?.validateRequest
-        });
-    };
-    Object.defineProperty(createHandler, EFFECT_VALIDATOR_AWARE_FACTORY, {
-        value: true
-    });
-    const client = createLoaderMaterializedClientPlaceholder();
-    return {
-        ...definition,
-        createHandler,
-        client
-    };
-}
-const LOADER_CLIENT_IGNORED_KEYS = new Set([
-    'then',
-    'catch',
-    'finally',
-    'toJSON',
-    '$$typeof'
-]);
-function createLoaderMaterializedClientPlaceholder() {
-    const explain = (property)=>{
-        throw new Error(`[BFF][Effect] client.${String(property)} is not available here: the typed client only exists when the API entry is imported through the "@api/index" transformed path (the BFF loader replaces it with generated client code). On the server, use HttpApiClient or call the Effect layer directly.`);
-    };
-    return new Proxy(Object.create(null), {
-        get (_target, property) {
-            if ('symbol' == typeof property || LOADER_CLIENT_IGNORED_KEYS.has(property)) return;
-            return explain(property);
-        }
-    });
-}
-function defineEffectRpcBff(definition) {
-    const createHandler = (options)=>createRpcApiHandler({
-            ...definition,
-            ...options
-        });
-    return {
-        ...definition,
-        createHandler
-    };
-}
-export { defineEffectBff, defineEffectRpcBff };

package/dist/esm-node/runtime/effect/handler/envelope.mjs

@@ -1,64 +0,0 @@
-import "node:module";
-import { DEFAULT_DATA_ENVELOPE_HEADER, decodeRequestEnvelopeHeader, validateRequestEnvelope, validateSelectionPlan } from "../../data-platform/index.mjs";
-import { getExpectedEnvelopeOrigin } from "./routing.mjs";
-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 || 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 = decodeRequestEnvelopeHeader(encodedEnvelope);
-    if (!envelope) return createInvalidEnvelopeResponse(`Invalid data envelope header format: ${envelopeHeader}`);
-    const validation = 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 = 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
-    };
-}
-export { mergeDataPlatformOptions, validateDataPlatformRequestEnvelope };

package/dist/esm-node/runtime/effect/handler/http.mjs

@@ -1,70 +0,0 @@
-import "node:module";
-import { HttpRouter, HttpServer } from "effect/unstable/http";
-import { prepareJsonRequestBody } from "./batch.mjs";
-import { createDataPlatformBatchRequestHandler } from "./batch-handler.mjs";
-import { validateDataPlatformRequestEnvelope } from "./envelope.mjs";
-import { createOpenApiLayer } from "./openapi.mjs";
-import { getRequestPathname, isRpcRequest } from "./routing.mjs";
-import { createRpcApiHandler, normalizeRpcPath } from "./rpc.mjs";
-import { toEffectServiceContext } from "./types.mjs";
-import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
-function createHttpApiHandler(options) {
-    const apiLayer = options.layer.pipe(__rspack_external_effect_Layer_69c46453.provide(HttpServer.layerServices));
-    const openApiLayer = createOpenApiLayer(options.api, options.openapi);
-    const mergedLayer = openApiLayer ? __rspack_external_effect_Layer_69c46453.mergeAll(apiLayer, openApiLayer) : apiLayer;
-    const httpApiHandler = HttpRouter.toWebHandler(mergedLayer);
-    const dispatchHttpApiRequest = async (request, context)=>{
-        const preparedRequest = await prepareJsonRequestBody(request);
-        if (preparedRequest instanceof Response) return preparedRequest;
-        const validationError = validateDataPlatformRequestEnvelope(preparedRequest, options.dataPlatform);
-        if (validationError) return validationError;
-        return httpApiHandler.handler(preparedRequest, toEffectServiceContext(context));
-    };
-    const withRequestPolicy = async (request, context)=>{
-        const policyDenial = options.validateRequest?.(request);
-        if (policyDenial) return policyDenial;
-        const next = ()=>dispatchHttpApiRequest(request, context);
-        return options.interceptRequest ? options.interceptRequest({
-            request,
-            next
-        }) : next();
-    };
-    const batchHandler = createDataPlatformBatchRequestHandler({
-        dataPlatform: options.dataPlatform,
-        handleItem: withRequestPolicy
-    });
-    const handleHttpApiRequest = async (request, context)=>{
-        const pathname = getRequestPathname(request);
-        if (batchHandler.enabled && pathname === batchHandler.path) return batchHandler.handle(request, context);
-        return withRequestPolicy(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)) {
-                const policyDenial = options.validateRequest?.(request);
-                if (policyDenial) return policyDenial;
-                const next = ()=>rpcHandler.handler(request, toEffectServiceContext(context));
-                return options.interceptRequest ? options.interceptRequest({
-                    request,
-                    next
-                }) : next();
-            }
-            return handleHttpApiRequest(request, context);
-        },
-        dispose: async ()=>{
-            await Promise.all([
-                httpApiHandler.dispose(),
-                rpcHandler.dispose()
-            ]);
-        }
-    };
-}
-export { createHttpApiHandler };

package/dist/esm-node/runtime/effect/handler/openapi.mjs

@@ -1,20 +0,0 @@
-import "node:module";
-import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
-import { OpenApi } from "effect/unstable/httpapi";
-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 createOpenApiLayer(api, openapi) {
-    const openApiOptions = getOpenApiOptions(openapi);
-    if (!openApiOptions) return null;
-    return HttpRouter.add('GET', openApiOptions.path, HttpServerResponse.jsonUnsafe(OpenApi.fromApi(api)));
-}
-export { createOpenApiLayer };

package/dist/esm-node/runtime/effect/handler/routing.mjs

@@ -1,51 +0,0 @@
-import "node:module";
-import { isPlainObject } from "../../data-platform/index.mjs";
-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}/`);
-}
-export { getExpectedEnvelopeOrigin, getMountedPrefixFromContext, getRequestPathname, isRpcRequest, removeMountedPrefixFromBatchPath };

package/dist/esm-node/runtime/effect/handler/rpc.mjs

@@ -1,23 +0,0 @@
-import "node:module";
-import { HttpRouter } from "effect/unstable/http";
-import { RpcServer } from "effect/unstable/rpc";
-import { getRpcSerializationLayer } from "../rpcSerialization.mjs";
-import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
-function normalizeRpcPath(pathname) {
-    if (!pathname || '/' === pathname) return '/rpc';
-    if (!pathname.startsWith('/')) return `/${pathname}`;
-    return pathname;
-}
-function createRpcApiHandler(options) {
-    const rpcPath = normalizeRpcPath(options.path);
-    const rpcLayer = __rspack_external_effect_Layer_69c46453.provide(RpcServer.layerHttp({
-        group: options.group,
-        path: rpcPath,
-        protocol: 'http',
-        disableTracing: options.disableTracing,
-        spanPrefix: options.spanPrefix,
-        spanAttributes: options.spanAttributes
-    }), __rspack_external_effect_Layer_69c46453.mergeAll(options.layer, getRpcSerializationLayer(options.serialization)));
-    return HttpRouter.toWebHandler(rpcLayer);
-}
-export { createRpcApiHandler, normalizeRpcPath };

package/dist/esm-node/runtime/effect/handler/types.mjs

@@ -1,6 +0,0 @@
-import "node:module";
-import * as __rspack_external_effect_Context_b3520bd3 from "effect/Context";
-const emptyEffectServiceContext = __rspack_external_effect_Context_b3520bd3.empty();
-const isEffectServiceContext = (context)=>'object' == typeof context && null !== context && 'mapUnsafe' in context;
-const toEffectServiceContext = (context)=>isEffectServiceContext(context) ? context : emptyEffectServiceContext;
-export { toEffectServiceContext };

package/dist/esm-node/runtime/effect/handler.mjs

@@ -1,15 +0,0 @@
-import "node:module";
-import * as __rspack_external_effect_Config_76cfa59d from "effect/Config";
-import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
-import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
-import * as __rspack_external_effect_Option_0498e63a from "effect/Option";
-import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
-export * from "effect/unstable/http";
-export * from "effect/unstable/httpapi";
-export * from "effect/unstable/rpc";
-export { HttpTraceContext } from "effect/unstable/http";
-export { HttpApiBuilder } from "effect/unstable/httpapi";
-export { EFFECT_VALIDATOR_AWARE_FACTORY, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
-export { defineEffectBff, defineEffectRpcBff } from "./handler/definition.mjs";
-export { createHttpApiHandler } from "./handler/http.mjs";
-export { __rspack_external_effect_Config_76cfa59d as Config, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Option_0498e63a as Option, __rspack_external_effect_Schema_6065f72d as Schema };

package/dist/esm-node/runtime/effect/module.mjs

@@ -1,76 +0,0 @@
-import "node:module";
-import { HttpApi } from "effect/unstable/httpapi";
-import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, strictEffectApproachMessage } from "./entry-shape.mjs";
-import { createHttpApiHandler } from "./handler.mjs";
-import * as __rspack_external_effect_Context_b3520bd3 from "effect/Context";
-function isRequestHandler(value) {
-    return 'function' == typeof value;
-}
-function isEffectServiceContext(context) {
-    return 'object' == typeof context && null !== context && 'mapUnsafe' in context;
-}
-const emptyEffectServiceContext = __rspack_external_effect_Context_b3520bd3.empty();
-function rejectLegacyEffectModuleShape(options, shape) {
-    options.onWarning?.(`${strictEffectApproachMessage} Rejected ${shape}.`);
-    return true;
-}
-function callEffectBffRequestHandler(handler, request, context) {
-    return void 0 === context ? handler(request) : handler(request, context);
-}
-function createLoadedHandler(webHandler) {
-    return {
-        handler: (request, context)=>callEffectBffRequestHandler(webHandler.handler, request, context),
-        dispose: webHandler.dispose
-    };
-}
-function createLoadedHttpApiHandler(webHandler) {
-    return {
-        handler: (request, context)=>{
-            const effectContext = isEffectServiceContext(context) ? context : emptyEffectServiceContext;
-            return webHandler.handler(request, effectContext);
-        },
-        dispose: webHandler.dispose
-    };
-}
-function classifyEffectBffRuntimeEntryShape(module) {
-    return classifyEffectBffEntryModule(module, {
-        isRequestHandler: isRequestHandler,
-        isValidatorAwareHandlerFactory: isValidatorAwareHandlerFactory,
-        isHttpApi: HttpApi.isHttpApi
-    });
-}
-function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
-    if (!facts) return null;
-    if (facts.legacyShape) {
-        if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) return null;
-    }
-    if ('function' == typeof facts.createHandler) {
-        if (!facts.createHandlerValidatorAware && rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export')) return null;
-        const factory = facts.createHandler;
-        const webHandler = factory({
-            openapi: options.openapi,
-            dataPlatform: options.dataPlatform,
-            validateRequest: options.validateRequest
-        });
-        return createLoadedHandler(webHandler);
-    }
-    if (void 0 !== facts.api && facts.hasRuntimeLayer) {
-        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 = createHttpApiHandler({
-            api: facts.api,
-            layer: facts.layer,
-            openapi: options.openapi,
-            dataPlatform: options.dataPlatform,
-            validateRequest: options.validateRequest
-        });
-        return createLoadedHttpApiHandler(webHandler);
-    }
-    return null;
-}
-function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
-    return resolveClassifiedEffectBffModuleHandler(classifyEffectBffRuntimeEntryShape(normalizedModule), options);
-}
-function resolveEffectBffModuleHandler(mod, options = {}) {
-    return Promise.resolve(resolveNormalizedEffectBffModuleHandler(mod, options));
-}
-export { resolveEffectBffModuleHandler };

package/dist/esm-node/runtime/effect/operation-context.mjs

@@ -1,66 +0,0 @@
-import "node:module";
-import { BFF_LOCALE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, BFF_TRACEPARENT_HEADER, parseTraceparent } from "@modern-js/create-request";
-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 readOperationContextDetails = (request)=>{
-    const rawDetails = readHeader(request.headers, 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, BFF_TRACEPARENT_HEADER) || details.traceparent;
-    const parsedTraceparent = details.traceId && details.spanId ? {
-        traceId: details.traceId,
-        spanId: details.spanId
-    } : parseTraceparent(traceparent);
-    const locale = readHeader(request.headers, BFF_LOCALE_HEADER);
-    const headerOperationId = readHeader(request.headers, 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
-        } : {}
-    };
-};
-export { createEffectOperationContext };

package/dist/esm-node/runtime/effect/rpcSerialization.mjs

@@ -1,17 +0,0 @@
-import "node:module";
-import { RpcSerialization } from "effect/unstable/rpc";
-function getRpcSerializationLayer(serialization) {
-    switch(serialization){
-        case 'ndjson':
-            return RpcSerialization.layerNdjson;
-        case 'jsonRpc':
-            return RpcSerialization.layerJsonRpc();
-        case 'ndJsonRpc':
-            return RpcSerialization.layerNdJsonRpc();
-        case 'msgPack':
-            return RpcSerialization.layerMsgPack;
-        default:
-            return RpcSerialization.layerJsonRpc();
-    }
-}
-export { getRpcSerializationLayer };

package/dist/esm-node/runtime/effect-client/batch.mjs

@@ -1,36 +0,0 @@
-import "node:module";
-import { createDataBatchTransport } from "../data-platform/index.mjs";
-import { resolveOrigin } from "./envelope.mjs";
-const resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
-const configureGeneratedEffectClientRuntime = (config, configureRequest)=>{
-    const defaultOrigin = config.defaultOrigin;
-    if (config.requestId && configureRequest) {
-        const configurePayload = {
-            requestId: config.requestId,
-            requireEnvelope: true,
-            identityBinding: {
-                enabled: true,
-                strict: true
-            },
-            operationContract: {
-                enabled: true,
-                strict: true,
-                requireSchemaHash: true,
-                requireOperationVersion: true
-            },
-            setDomain: ()=>resolveOrigin(defaultOrigin)
-        };
-        const runtimeFetch = resolveRuntimeFetch();
-        if (false !== config.batch.enabled && runtimeFetch) configurePayload.request = createDataBatchTransport({
-            fetch: runtimeFetch,
-            endpoint: config.batch.endpoint,
-            flushIntervalMs: config.batch.flushIntervalMs,
-            maxBatchSize: config.batch.maxBatchSize,
-            maxBatchBytes: config.batch.maxBatchBytes,
-            requestTimeoutMs: config.batch.requestTimeoutMs,
-            allowedMethods: config.batch.allowedMethods
-        });
-        configureRequest(configurePayload);
-    }
-};
-export { configureGeneratedEffectClientRuntime };