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

package/src/effect/entry-shape.ts

@@ -1,8 +1,21 @@
+import {
+  adoptEffectContextStorage,
+  EFFECT_BFF_CONTEXT_STORAGE_SHARE,
+} from '@modern-js/bff-effect/context';
+import type { EffectRpcBffDefinition } from './handler/types';
+
 type ValidatorAwareHandlerFactoryRegistry = {
   register<TFactory extends Function>(factory: TFactory): TFactory;
   is(factory: unknown): boolean;
 };
 
+/**
+ * Module Federation share through which a backend federation host hands its
+ * package-private handler factory registry to the containers it initializes.
+ */
+export const EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE =
+  '@modern-js/bff-effect/handler-factory-registry';
+
 function createLocalValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandlerFactoryRegistry {
   const factories = new WeakSet<Function>();
   return {
@@ -19,6 +32,8 @@ function createLocalValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandle
 function loadNodeValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandlerFactoryRegistry {
   const moduleUrl = import.meta.url;
   if (typeof moduleUrl !== 'string' || !moduleUrl.startsWith('file:')) {
+    // A bundled backend federation container has no file URL; its host share
+    // arrives through adoptEffectBffShareScope() during container init.
     return createLocalValidatorAwareHandlerFactoryRegistry();
   }
 
@@ -42,24 +57,104 @@ function loadNodeValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandlerFa
   }
 }
 
-const validatorAwareHandlerFactoryRegistry =
-  process.env.MODERN_EFFECT_NODE_RUNTIME === 'true'
-    ? loadNodeValidatorAwareHandlerFactoryRegistry()
-    : createLocalValidatorAwareHandlerFactoryRegistry();
+declare const __MODERN_EFFECT_NODE_RUNTIME__: boolean;
+
+let validatorAwareHandlerFactoryRegistry:
+  | ValidatorAwareHandlerFactoryRegistry
+  | undefined;
+
+function handlerFactoryRegistry(): ValidatorAwareHandlerFactoryRegistry {
+  validatorAwareHandlerFactoryRegistry ??=
+    typeof __MODERN_EFFECT_NODE_RUNTIME__ !== 'undefined' &&
+    __MODERN_EFFECT_NODE_RUNTIME__
+      ? loadNodeValidatorAwareHandlerFactoryRegistry()
+      : createLocalValidatorAwareHandlerFactoryRegistry();
+  return validatorAwareHandlerFactoryRegistry;
+}
+
+type SharedVersions = Record<string, { get?: () => unknown } | undefined>;
+
+const adoptShared = (
+  shareScope: unknown,
+  name: string,
+  adopt: (value: unknown) => void,
+): Promise<void> => {
+  const versions =
+    typeof shareScope === 'object' && shareScope !== null
+      ? (shareScope as Record<string, SharedVersions | undefined>)[name]
+      : undefined;
+  const shared =
+    versions === undefined ? undefined : Object.values(versions)[0];
+  if (typeof shared?.get !== 'function') {
+    return Promise.resolve();
+  }
+  return Promise.resolve(shared.get()).then(factory =>
+    adopt(typeof factory === 'function' ? factory() : undefined),
+  );
+};
+
+/**
+ * @internal Called by generated backend federation containers from `init()`,
+ * before any expose evaluates, so factories created by `defineEffectBff`
+ * register with the host's registry and endpoints read the host's request
+ * storage instead of bundle-local ones.
+ */
+export function adoptEffectBffShareScope(shareScope: unknown): Promise<void> {
+  return Promise.all([
+    adoptShared(
+      shareScope,
+      EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE,
+      registry =>
+        adoptHandlerFactoryRegistry(
+          registry as ValidatorAwareHandlerFactoryRegistry | undefined,
+        ),
+    ),
+    adoptShared(
+      shareScope,
+      EFFECT_BFF_CONTEXT_STORAGE_SHARE,
+      adoptEffectContextStorage,
+    ),
+  ]).then(() => undefined);
+}
+
+function adoptHandlerFactoryRegistry(
+  registry: ValidatorAwareHandlerFactoryRegistry | undefined,
+): void {
+  if (
+    typeof registry?.register !== 'function' ||
+    typeof registry.is !== 'function'
+  ) {
+    throw new Error(
+      `[BFF][Effect] Share ${EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE} must provide a handler factory registry.`,
+    );
+  }
+  if (
+    validatorAwareHandlerFactoryRegistry !== undefined &&
+    validatorAwareHandlerFactoryRegistry !== registry
+  ) {
+    throw new Error(
+      '[BFF][Effect] A backend federation container received the host handler factory registry after an Effect API already used its own. Evaluate exposes only after container init().',
+    );
+  }
+  validatorAwareHandlerFactoryRegistry = registry;
+}
 
 type EffectBffEntryModule = {
   api?: unknown;
   layer?: unknown;
+  rpc?: EffectRpcBffDefinition;
   handler?: unknown;
   createHandler?: unknown;
   default?: unknown;
 };
 
-type LegacyEffectBffEntryShape = '`handler` export' | 'default request handler';
+type UnsupportedEffectBffEntryShape =
+  | '`handler` export'
+  | 'default request handler';
 
 export type EffectBffEntryShapeFacts = {
   module: EffectBffEntryModule;
-  legacyShape?: LegacyEffectBffEntryShape;
+  unsupportedShape?: UnsupportedEffectBffEntryShape;
   createHandler?: unknown;
   createHandlerValidatorAware: boolean;
   api?: unknown;
@@ -77,7 +172,7 @@ type EffectBffEntryShapePredicates = {
 export function registerValidatorAwareHandlerFactory<TFactory extends Function>(
   factory: TFactory,
 ): TFactory {
-  return validatorAwareHandlerFactoryRegistry.register(factory);
+  return handlerFactoryRegistry().register(factory);
 }
 
 /**
@@ -85,7 +180,7 @@ export function registerValidatorAwareHandlerFactory<TFactory extends Function>(
  * therefore forwards strict cross-project validation into createHttpApiHandler.
  */
 export function isValidatorAwareHandlerFactory(factory: unknown): boolean {
-  return validatorAwareHandlerFactoryRegistry.is(factory);
+  return handlerFactoryRegistry().is(factory);
 }
 
 export const strictEffectApproachMessage =
@@ -132,7 +227,7 @@ export function classifyEffectBffEntryModule(
 function createEntryShapeFacts(
   module: EffectBffEntryModule,
   predicates: EffectBffEntryShapePredicates,
-  legacyShape?: LegacyEffectBffEntryShape,
+  unsupportedShape?: UnsupportedEffectBffEntryShape,
 ): EffectBffEntryShapeFacts {
   const createHandler =
     typeof module.createHandler === 'function'
@@ -143,7 +238,7 @@ function createEntryShapeFacts(
 
   return {
     module,
-    legacyShape,
+    unsupportedShape,
     createHandler,
     createHandlerValidatorAware:
       createHandler !== undefined &&

package/src/effect/generated-entry.ts

@@ -0,0 +1,36 @@
+import {
+  createEffectBffEdgeDispatcher,
+  type EffectBffEdgeHandlerOptions,
+} from './edge-dispatcher';
+
+type OperationContracts = NonNullable<
+  EffectBffEdgeHandlerOptions['crossProjectPolicy']
+>['expectedOperationContracts'];
+
+export function createEffectBffEdgeDispatcherFactory(
+  module: EffectBffEdgeHandlerOptions['module'],
+  generatedOperationContracts: OperationContracts,
+) {
+  return (options?: Omit<EffectBffEdgeHandlerOptions, 'module'>) => {
+    const policy = options?.crossProjectPolicy;
+    const crossProjectPolicy =
+      policy === undefined ||
+      policy === null ||
+      policy.expectedOperationContracts === null ||
+      typeof policy.expectedOperationContracts !== 'object' ||
+      Array.isArray(policy.expectedOperationContracts)
+        ? policy
+        : {
+            ...policy,
+            expectedOperationContracts: {
+              ...policy.expectedOperationContracts,
+              ...generatedOperationContracts,
+            },
+          };
+    return createEffectBffEdgeDispatcher({
+      ...options,
+      crossProjectPolicy,
+      module,
+    });
+  };
+}

package/src/effect/handler/batch-handler.ts

@@ -1,4 +1,5 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
+import * as Effect from 'effect/Effect';
 import {
   type DataBatchResponsePayload,
   DEFAULT_DATA_BATCH_HEADER,
@@ -7,6 +8,7 @@ import {
   isPlainObject,
   normalizeMethod as normalizeItemMethod,
 } from '../../data-platform';
+import { normalizeBatchLimits } from '../../data-platform/batch/options';
 import {
   decodeBatchBody,
   isBatchBody,
@@ -17,7 +19,6 @@ import {
   createBatchValidationResponse,
   isBatchRequestPayload,
   mapWithConcurrency,
-  normalizeBatchAllowedMethods,
   normalizeBatchPath,
   promiseWithTimeout,
   toBatchItemError,
@@ -128,14 +129,11 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
   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 ?? 64 * 1024,
-  );
+  const {
+    maxBatchSize: batchMaxSize,
+    maxBatchBytes: batchMaxBytes,
+    allowedMethods: batchAllowedMethods,
+  } = normalizeBatchLimits(dataPlatformBatchOptions);
   const batchConcurrency = Math.max(
     1,
     dataPlatformBatchOptions?.maxConcurrency ?? 4,
@@ -144,9 +142,6 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
     0,
     dataPlatformBatchOptions?.requestTimeoutMs ?? 10_000,
   );
-  const batchAllowedMethods = normalizeBatchAllowedMethods(
-    dataPlatformBatchOptions?.allowedMethods,
-  );
   const envelopeHeader =
     options.dataPlatform?.envelopeHeader || DEFAULT_DATA_ENVELOPE_HEADER;
   const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
@@ -417,14 +412,16 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
           );
         } catch (error) {
           if (error instanceof BatchItemTimeoutError) {
-            console.error({
-              event: 'bff.batch.item.timeout',
-              batchId: payload.batchId,
-              itemId,
-              method: itemMethod,
-              path: itemPathname,
-              errorName: error.name,
-            });
+            Effect.runSync(
+              Effect.logError({
+                event: 'bff.batch.item.timeout',
+                batchId: payload.batchId,
+                itemId,
+                method: itemMethod,
+                path: itemPathname,
+                errorName: error.name,
+              }),
+            );
             return toBatchItemError(
               itemId,
               504,
@@ -435,14 +432,16 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
             return toBatchResponseItem(itemId, error, itemMethod === 'HEAD');
           }
 
-          console.error({
-            event: 'bff.batch.item.failure',
-            batchId: payload.batchId,
-            itemId,
-            method: itemMethod,
-            path: itemPathname,
-            errorName: error instanceof Error ? error.name : 'UnknownError',
-          });
+          Effect.runSync(
+            Effect.logError({
+              event: 'bff.batch.item.failure',
+              batchId: payload.batchId,
+              itemId,
+              method: itemMethod,
+              path: itemPathname,
+              errorName: error instanceof Error ? error.name : 'UnknownError',
+            }),
+          );
           return toBatchItemError(itemId, 500, 'Internal Server Error');
         } finally {
           request.signal.removeEventListener('abort', abortFromBatchRequest);

package/src/effect/handler/batch.ts

@@ -1,15 +1,14 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
 
+import * as Data from 'effect/Data';
 import {
   type DataBatchRequestPayload,
   type DataBatchResponseItem,
   DEFAULT_DATA_BATCH_ENDPOINT,
   isPlainObject,
-  measureTextBytes,
   normalizeMethod as normalizeItemMethod,
 } from '../../data-platform';
 import { encodeBatchText } from '../../data-platform/batch/protocol';
-import { toHeaderRecord } from '../../headers';
 
 export { toHeaderRecord } from '../../headers';
 
@@ -23,16 +22,6 @@ export function normalizeBatchPath(pathname: string | undefined) {
   return pathname as `/${string}`;
 }
 
-export function normalizeBatchAllowedMethods(
-  allowedMethods: string[] | undefined,
-) {
-  const source =
-    Array.isArray(allowedMethods) && allowedMethods.length > 0
-      ? allowedMethods
-      : ['GET'];
-  return new Set(source.map(method => method.toUpperCase()));
-}
-
 type ParsedBatchRequestPayload = Omit<DataBatchRequestPayload, 'items'> & {
   items: unknown[];
 };
@@ -117,7 +106,14 @@ export function toBatchItemError(
   };
 }
 
-export class BatchItemTimeoutError extends Error {}
+export class BatchItemTimeoutError extends Data.TaggedError(
+  'BatchItemTimeoutError',
+)<{ readonly message: string }> {
+  constructor(message: string) {
+    super({ message });
+    this.name = 'Error';
+  }
+}
 
 export function promiseWithTimeout<T>(
   effect: Promise<T>,

package/src/effect/handler/definition.ts

@@ -7,11 +7,9 @@ import { mergeDataPlatformOptions } from './envelope';
 import { createHttpApiHandler } from './http';
 import { createRpcApiHandler } from './rpc';
 import type {
-  EffectApiPromiseClientFromApi,
   EffectBffDefinition,
   EffectBffHandlerFactory,
   EffectBffRuntime,
-  EffectDataPlatformValidationOptions,
   EffectRpcBffDefinition,
   EffectRpcBffHandlerFactory,
   EffectRpcRuntimeLayer,
@@ -51,55 +49,12 @@ export function defineEffectBff<
       validateRequest: options?.validateRequest,
     });
   });
-  const client = createLoaderMaterializedClientPlaceholder<TApi>();
   return {
     ...definition,
     createHandler,
-    client,
   };
 }
 
-const LOADER_CLIENT_IGNORED_KEYS = new Set<PropertyKey>([
-  'then',
-  'catch',
-  'finally',
-  'toJSON',
-  '$$typeof',
-]);
-
-/**
- * `defineEffectBff(...).client` is only materialized when the entry module
- * is imported through the `@api/index` transform (the webpack/rspack
- * loader swaps the module for generated client code). Importing the entry
- * directly (server code, scripts, tests) used to return a `client` typed as
- * fully functional but `undefined` at runtime — a bare TypeError with zero
- * explanation. This placeholder keeps the type contract while failing with
- * an actionable error on first property access.
- */
-function createLoaderMaterializedClientPlaceholder<
-  TApi extends HttpApi.Constraint,
->(): EffectApiPromiseClientFromApi<TApi> {
-  const explain = (property: PropertyKey): never => {
-    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) {
-      // Keep async/inspection protocols (await, console.log, React internals)
-      // from throwing so the placeholder stays inert until really used.
-      if (
-        typeof property === 'symbol' ||
-        LOADER_CLIENT_IGNORED_KEYS.has(property)
-      ) {
-        return undefined;
-      }
-      return explain(property);
-    },
-  }) as EffectApiPromiseClientFromApi<TApi>;
-}
-
 export function defineEffectRpcBff<
   TRpcs extends Rpc.Any = Rpc.Any,
   TLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>,

package/src/effect/handler/http.ts

@@ -66,8 +66,8 @@ export function createHttpApiHandler<
   ) => {
     // Policy seam first: every HttpApi request, direct or batched item,
     // passes through here, so batch fan-out cannot bypass validator. The
-    // interceptor receives the original request and may own malformed or
-    // legacy payloads; delegated requests still pass through body validation.
+    // interceptor receives the original request; delegated requests still
+    // pass through body validation.
     const policyDenial = options.validateRequest?.(request);
     if (policyDenial) {
       return policyDenial;

package/src/effect/handler/types.ts

@@ -1,7 +1,6 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
 import type { FileSystem, Path } from 'effect';
 import * as Context from 'effect/Context';
-import type * as EffectType from 'effect/Effect';
 import type * as Layer from 'effect/Layer';
 import type { Etag, HttpPlatform, HttpRouter } from 'effect/unstable/http';
 import type {
@@ -43,8 +42,7 @@ export type EffectRpcSerialization =
   | 'json'
   | 'ndjson'
   | 'jsonRpc'
-  | 'ndJsonRpc'
-  | 'msgPack';
+  | 'ndJsonRpc';
 
 export type EffectRpcRuntimeLayer<TRpcs extends Rpc.Any = Rpc.Any> =
   Layer.Layer<
@@ -77,22 +75,6 @@ export type EffectRpcBffHandlerOptions = Pick<
   | 'disableFatalDefects'
 >;
 
-type EffectApiPromiseClient<TClient> = {
-  [GroupName in keyof TClient]: {
-    [EndpointName in keyof TClient[GroupName]]: TClient[GroupName][EndpointName] extends (
-      ...args: infer TArgs
-    ) => infer TResult
-      ? TResult extends EffectType.Effect<unknown, unknown, unknown>
-        ? (
-            ...args: TArgs
-          ) => Promise<
-            Exclude<EffectType.Success<TResult>, readonly [unknown, unknown]>
-          >
-        : never
-      : never;
-  };
-};
-
 export type EffectApiClientFromApi<
   TApi extends HttpApi.Constraint = HttpApi.Top,
 > =
@@ -104,10 +86,6 @@ export type EffectApiClientFromApi<
       >
     : never;
 
-export type EffectApiPromiseClientFromApi<
-  TApi extends HttpApi.Constraint = HttpApi.Top,
-> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
-
 export type EffectBffDefinition<
   TApi extends HttpApi.Constraint = HttpApi.Top,
   TLayer extends EffectRuntimeLayer = EffectRuntimeLayer,
@@ -147,12 +125,6 @@ export type EffectDataPlatformBatchOptions = {
    * Defaults to `65536` (64KiB).
    */
   maxBatchBytes?: number;
-  /**
-   * Client-side micro-batch flush window in milliseconds.
-   * Server runtime ignores this value and passes it through for codegen.
-   * Defaults to `8`.
-   */
-  flushIntervalMs?: number;
   /**
    * Maximum per-batch internal request concurrency.
    * Defaults to `4`.
@@ -227,8 +199,8 @@ export type EffectRequestInterceptor = (options: {
 }) => Response | Promise<Response>;
 
 export type EffectBffHandlerFactory<
-  TApi extends HttpApi.Constraint = HttpApi.Top,
-  TLayer extends EffectRuntimeLayer = EffectRuntimeLayer,
+  _TApi extends HttpApi.Constraint = HttpApi.Top,
+  _TLayer extends EffectRuntimeLayer = EffectRuntimeLayer,
 > = (options?: {
   openapi?: EffectBffOpenApiConfig;
   rpc?: Partial<EffectRpcBffHandlerOptions>;
@@ -241,7 +213,6 @@ export type EffectBffRuntime<
   TLayer extends EffectRuntimeLayer = EffectRuntimeLayer,
 > = {
   createHandler: EffectBffHandlerFactory<TApi, TLayer>;
-  client: EffectApiPromiseClientFromApi<TApi>;
 };
 
 export type EffectBffOpenApiConfig =

package/src/effect/handler.ts

@@ -14,7 +14,6 @@ export { defineEffectBff, defineEffectRpcBff } from './handler/definition';
 export { createHttpApiHandler } from './handler/http';
 export type {
   EffectApiClientFromApi,
-  EffectApiPromiseClientFromApi,
   EffectBffDefinition,
   EffectBffHandlerFactory,
   EffectBffOpenApiConfig,

package/src/effect/index.ts

@@ -6,7 +6,7 @@ export {
   runWithEffectContext,
   useEffectContext,
   useOperationContext,
-} from './context';
+} from '@modern-js/bff-effect/context';
 export {
   createEffectBffEdgeHandler,
   createEffectBffTestHandler,

package/src/effect/module.ts

@@ -12,6 +12,7 @@ import {
   type EffectBffOpenApiConfig,
   type EffectDataPlatformValidationOptions,
   type EffectRequestValidator,
+  type EffectRpcBffDefinition,
   type EffectRuntimeLayer,
 } from './handler';
 import type { EffectContext } from './operation-context';
@@ -33,6 +34,7 @@ export type EffectBffHandlerFactory = (options?: {
 export type EffectApiModule = {
   api?: unknown;
   layer?: unknown;
+  rpc?: EffectRpcBffDefinition;
   handler?: EffectBffRequestHandler;
   createHandler?: EffectBffHandlerFactory;
   default?: unknown;
@@ -67,7 +69,7 @@ function shareDispose(dispose: () => Promise<void>) {
   };
 }
 
-function rejectLegacyEffectModuleShape(
+function rejectUnsupportedEffectModuleShape(
   options: ResolveEffectBffModuleHandlerOptions,
   shape: string,
 ) {
@@ -119,12 +121,17 @@ function resolveClassifiedEffectBffModuleHandler(
     return null;
   }
 
-  if (facts.legacyShape) {
-    if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) {
+  if (facts.unsupportedShape) {
+    if (rejectUnsupportedEffectModuleShape(options, facts.unsupportedShape)) {
       return null;
     }
   }
 
+  if (facts.module.rpc !== undefined && !facts.createHandlerValidatorAware) {
+    rejectUnsupportedEffectModuleShape(options, 'unbranded RPC runtime');
+    return null;
+  }
+
   if (typeof facts.createHandler === 'function') {
     if (facts.createHandlerValidatorAware) {
       const factory = facts.createHandler as EffectBffHandlerFactory;
@@ -137,7 +144,7 @@ function resolveClassifiedEffectBffModuleHandler(
     }
 
     if (facts.api === undefined || !facts.hasRuntimeLayer) {
-      rejectLegacyEffectModuleShape(
+      rejectUnsupportedEffectModuleShape(
         options,
         'unbranded `createHandler` export',
       );

package/src/effect/operation-context.ts

@@ -6,7 +6,7 @@ import {
   BFF_TRACEPARENT_HEADER,
   type OperationContext,
   parseTraceparent,
-} from '@modern-js/create-request';
+} from '@modern-js/runtime-extensions/request-context';
 
 export type EffectContext = {
   request: Request;
@@ -21,10 +21,6 @@ export type EffectContextStorage = {
   run: <TResult>(value: EffectContext, cb: () => TResult) => TResult;
 };
 
-export const kEffectContextStorage = Symbol.for(
-  'modernjs.plugin-bff.effectContextStorage',
-);
-
 export type CreateEffectOperationContextOptions = Omit<
   EffectContext,
   'operationContext'
@@ -128,7 +124,7 @@ export const createEffectOperationContext = ({
       : {}),
     routePath: servicePath,
     method: (method || request.method || 'GET').toUpperCase(),
-    source: 'effect-adapter',
+    source: 'effect-server',
     ...(path && path !== servicePath
       ? { attributes: { mountedPath: path } }
       : {}),

package/src/effect/rpcSerialization.ts

@@ -12,8 +12,6 @@ export function getRpcSerializationLayer(
       return RpcSerialization.layerJsonRpc();
     case 'ndJsonRpc':
       return RpcSerialization.layerNdJsonRpc();
-    case 'msgPack':
-      return RpcSerialization.layerMsgPack;
     default:
       return RpcSerialization.layerJsonRpc();
   }