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

package/src/effect/edge-dispatcher.ts

@@ -1,4 +1,6 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off strictBooleanExpressions:off
+
+import { runWithEffectContext } from '@modern-js/bff-effect/context';
 import {
   evaluateCrossProjectPolicy,
   type NormalizedCrossProjectPolicy,
@@ -10,7 +12,6 @@ import {
   type DispatchEffectBffRequestOptions,
   dispatchEffectBffRequestWithContext,
 } from './dispatch';
-import { runWithEffectContext } from './edge-context';
 import type {
   EffectBffOpenApiConfig,
   EffectDataPlatformValidationOptions,
@@ -22,11 +23,13 @@ import {
 } from './module';
 import type { EffectContext } from './operation-context';
 
+export {
+  runWithEffectContext,
+  useEffectContext,
+  useOperationContext,
+} from '@modern-js/bff-effect/context';
 export * as Config from 'effect/Config';
 export * as Effect from 'effect/Effect';
-export * as Layer from 'effect/Layer';
-export * as Option from 'effect/Option';
-export * as Schema from 'effect/Schema';
 export {
   Cookies,
   Etag,
@@ -57,7 +60,7 @@ export {
   Template,
   Url,
   UrlParams,
-} from 'effect/unstable/http';
+} from 'effect/http';
 export {
   HttpApi,
   HttpApiBuilder,
@@ -70,7 +73,9 @@ export {
   HttpApiSecurity,
   HttpApiTest,
   OpenApi,
-} from 'effect/unstable/httpapi';
+} from 'effect/http-api';
+export * as Layer from 'effect/Layer';
+export * as Option from 'effect/Option';
 export {
   Rpc,
   RpcClient,
@@ -84,12 +89,8 @@ export {
   RpcTest,
   RpcWorker,
   Utils,
-} from 'effect/unstable/rpc';
-export {
-  runWithEffectContext,
-  useEffectContext,
-  useOperationContext,
-} from './edge-context';
+} from 'effect/rpc';
+export * as Schema from 'effect/Schema';
 export type {
   EffectApiClientFromApi,
   EffectBffDefinition,

package/src/effect/edge.ts

@@ -1,2 +1,7 @@
+export { EFFECT_BFF_CONTEXT_STORAGE_SHARE } from '@modern-js/bff-effect/context';
 export * from './edge-dispatcher';
+export {
+  adoptEffectBffShareScope,
+  EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE,
+} from './entry-shape';
 export { createEffectBffEdgeDispatcherFactory } from './generated-entry';

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();
   }
 
@@ -44,15 +59,90 @@ function loadNodeValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandlerFa
 
 declare const __MODERN_EFFECT_NODE_RUNTIME__: boolean;
 
-const validatorAwareHandlerFactoryRegistry =
-  typeof __MODERN_EFFECT_NODE_RUNTIME__ !== 'undefined' &&
-  __MODERN_EFFECT_NODE_RUNTIME__
-    ? loadNodeValidatorAwareHandlerFactoryRegistry()
-    : createLocalValidatorAwareHandlerFactoryRegistry();
+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;
@@ -82,7 +172,7 @@ type EffectBffEntryShapePredicates = {
 export function registerValidatorAwareHandlerFactory<TFactory extends Function>(
   factory: TFactory,
 ): TFactory {
-  return validatorAwareHandlerFactoryRegistry.register(factory);
+  return handlerFactoryRegistry().register(factory);
 }
 
 /**
@@ -90,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 =

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

@@ -8,6 +8,7 @@ import {
   isPlainObject,
   normalizeMethod as normalizeItemMethod,
 } from '../../data-platform';
+import { normalizeBatchLimits } from '../../data-platform/batch/options';
 import {
   decodeBatchBody,
   isBatchBody,
@@ -18,7 +19,6 @@ import {
   createBatchValidationResponse,
   isBatchRequestPayload,
   mapWithConcurrency,
-  normalizeBatchAllowedMethods,
   normalizeBatchPath,
   promiseWithTimeout,
   toBatchItemError,
@@ -129,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,
@@ -145,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();

package/src/effect/handler/batch.ts

@@ -6,11 +6,9 @@ import {
   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';
 
@@ -24,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[];
 };

package/src/effect/handler/definition.ts

@@ -1,6 +1,6 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
-import type { HttpApi } from 'effect/unstable/httpapi';
-import type { Rpc } from 'effect/unstable/rpc';
+import type { HttpApi } from 'effect/http-api';
+import type { Rpc } from 'effect/rpc';
 
 import { registerValidatorAwareHandlerFactory } from '../entry-shape';
 import { mergeDataPlatformOptions } from './envelope';
@@ -10,7 +10,6 @@ import type {
   EffectBffDefinition,
   EffectBffHandlerFactory,
   EffectBffRuntime,
-  EffectDataPlatformValidationOptions,
   EffectRpcBffDefinition,
   EffectRpcBffHandlerFactory,
   EffectRpcRuntimeLayer,

package/src/effect/handler/http.ts

@@ -1,8 +1,9 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
+
+import { HttpRouter, HttpServer } from 'effect/http';
+import type { HttpApi } from 'effect/http-api';
 import * as Layer from 'effect/Layer';
-import { HttpRouter, HttpServer } from 'effect/unstable/http';
-import type { HttpApi } from 'effect/unstable/httpapi';
-import type { Rpc } from 'effect/unstable/rpc';
+import type { Rpc } from 'effect/rpc';
 
 import { prepareJsonRequestBody } from './batch';
 import { createDataPlatformBatchRequestHandler } from './batch-handler';

package/src/effect/handler/openapi.ts

@@ -1,6 +1,6 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
-import { HttpRouter, HttpServerResponse } from 'effect/unstable/http';
-import { type HttpApi, OpenApi } from 'effect/unstable/httpapi';
+import { HttpRouter, HttpServerResponse } from 'effect/http';
+import { type HttpApi, OpenApi } from 'effect/http-api';
 
 import type { EffectBffOpenApiConfig } from './types';
 

package/src/effect/handler/rpc.ts

@@ -1,7 +1,8 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
+
+import { HttpRouter } from 'effect/http';
 import * as Layer from 'effect/Layer';
-import { HttpRouter } from 'effect/unstable/http';
-import { type Rpc, RpcServer } from 'effect/unstable/rpc';
+import { type Rpc, RpcServer } from 'effect/rpc';
 
 import { getRpcSerializationLayer } from '../rpcSerialization';
 import type { EffectRpcBffDefinition } from './types';

package/src/effect/handler/types.ts

@@ -1,15 +1,10 @@
 // @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 { Etag, HttpPlatform, HttpRouter } from 'effect/http';
+import type { HttpApi, HttpApiClient, HttpApiGroup } from 'effect/http-api';
 import type * as Layer from 'effect/Layer';
-import type { Etag, HttpPlatform, HttpRouter } from 'effect/unstable/http';
-import type {
-  HttpApi,
-  HttpApiClient,
-  HttpApiGroup,
-} from 'effect/unstable/httpapi';
-import type { Rpc, RpcGroup } from 'effect/unstable/rpc';
+import type { Rpc, RpcGroup } from 'effect/rpc';
 
 import type { createHttpApiHandler } from './http';
 import type { createRpcApiHandler } from './rpc';
@@ -43,8 +38,7 @@ export type EffectRpcSerialization =
   | 'json'
   | 'ndjson'
   | 'jsonRpc'
-  | 'ndJsonRpc'
-  | 'msgPack';
+  | 'ndJsonRpc';
 
 export type EffectRpcRuntimeLayer<TRpcs extends Rpc.Any = Rpc.Any> =
   Layer.Layer<
@@ -201,8 +195,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>;

package/src/effect/handler.ts

@@ -1,14 +1,14 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
 export * as Config from 'effect/Config';
 export * as Effect from 'effect/Effect';
+export * from 'effect/http';
+export { HttpTraceContext } from 'effect/http';
+export * from 'effect/http-api';
+export { HttpApiBuilder } from 'effect/http-api';
 export * as Layer from 'effect/Layer';
 export * as Option from 'effect/Option';
+export * from 'effect/rpc';
 export * as Schema from 'effect/Schema';
-export * from 'effect/unstable/http';
-export { HttpTraceContext } from 'effect/unstable/http';
-export * from 'effect/unstable/httpapi';
-export { HttpApiBuilder } from 'effect/unstable/httpapi';
-export * from 'effect/unstable/rpc';
 
 export { defineEffectBff, defineEffectRpcBff } from './handler/definition';
 export { createHttpApiHandler } from './handler/http';

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

@@ -1,6 +1,6 @@
 // @effect-diagnostics strictBooleanExpressions:off
 import type * as EffectServiceContext from 'effect/Context';
-import { HttpApi } from 'effect/unstable/httpapi';
+import { HttpApi } from 'effect/http-api';
 import {
   classifyEffectBffEntryModule,
   type EffectBffEntryShapeFacts,
@@ -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;
@@ -125,6 +127,11 @@ function resolveClassifiedEffectBffModuleHandler(
     }
   }
 
+  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;

package/src/effect/operation-context.ts

@@ -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

@@ -1,4 +1,4 @@
-import { RpcSerialization } from 'effect/unstable/rpc';
+import { RpcSerialization } from 'effect/rpc';
 
 import type { EffectRpcSerialization } from './handler/types';
 
@@ -12,8 +12,6 @@ export function getRpcSerializationLayer(
       return RpcSerialization.layerJsonRpc();
     case 'ndJsonRpc':
       return RpcSerialization.layerNdJsonRpc();
-    case 'msgPack':
-      return RpcSerialization.layerMsgPack;
     default:
       return RpcSerialization.layerJsonRpc();
   }

package/src/effect-client/cross-project.ts

@@ -2,6 +2,7 @@ import {
   BFF_ENVELOPE_HEADER,
   BFF_OPERATION_CONTEXT_DETAIL_HEADER,
   BFF_OPERATION_CONTEXT_HEADER,
+  digestOperationContract,
   resolveCrossProjectRequestObservation,
 } from '@modern-js/server-runtime-extensions/bff-policy';
 import * as Effect from 'effect/Effect';
@@ -9,8 +10,8 @@ import * as Schema from 'effect/Schema';
 
 const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
 
-import { HttpClient, HttpClientRequest } from 'effect/unstable/http';
-import { HttpApi, type HttpApiGroup } from 'effect/unstable/httpapi';
+import { HttpClient, HttpClientRequest } from 'effect/http';
+import { HttpApi, type HttpApiGroup } from 'effect/http-api';
 
 export interface EffectCrossProjectClientOptions {
   requestId: string;
@@ -66,22 +67,16 @@ export function withCrossProjectPolicy<
         );
       }
       return Effect.gen(function* () {
-        // Canonical field order matches the server's route-identity SHA-256.
-        const input = encodeJson({
-          httpMethod: contract.method,
-          name: contract.name,
-          requestId: options.requestId,
-          routePath: contract.routePath,
-        });
-        const digest = yield* Effect.promise(() =>
-          globalThis.crypto.subtle.digest(
-            'SHA-256',
-            new TextEncoder().encode(input),
+        const schemaHash = yield* Effect.promise(() =>
+          digestOperationContract(
+            {
+              httpMethod: contract.method,
+              name: contract.name,
+              routePath: contract.routePath,
+            },
+            options.requestId,
           ),
         );
-        const schemaHash = Array.from(new Uint8Array(digest), value =>
-          value.toString(16).padStart(2, '0'),
-        ).join('');
         return request.pipe(
           HttpClientRequest.setHeader(
             BFF_ENVELOPE_HEADER,

package/src/effect-client/index.ts

@@ -6,28 +6,25 @@ import {
 import * as Data from 'effect/Data';
 import * as Effect from 'effect/Effect';
 import * as Exit from 'effect/Exit';
-import * as Layer from 'effect/Layer';
-import * as ManagedRuntime from 'effect/ManagedRuntime';
-import * as Scope from 'effect/Scope';
-import {
-  FetchHttpClient,
-  HttpClient,
-  HttpClientRequest,
-} from 'effect/unstable/http';
+import { FetchHttpClient, HttpClient, HttpClientRequest } from 'effect/http';
 import {
   HttpApi,
   HttpApiClient,
   HttpApiEndpoint,
   HttpApiGroup,
   HttpApiSchema,
-} from 'effect/unstable/httpapi';
+} from 'effect/http-api';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
 import {
   Rpc,
   RpcClient,
+  RpcClientError,
   RpcGroup,
   RpcSchema,
   RpcSerialization,
-} from 'effect/unstable/rpc';
+} from 'effect/rpc';
+import * as Scope from 'effect/Scope';
 
 import { getRpcSerializationLayer } from '../effect/rpcSerialization';
 import {
@@ -36,9 +33,9 @@ import {
 } from './cross-project';
 
 export * as Effect from 'effect/Effect';
+export * as HttpClientError from 'effect/http/HttpClientError';
 export * as Layer from 'effect/Layer';
 export * as Schema from 'effect/Schema';
-export * as HttpClientError from 'effect/unstable/http/HttpClientError';
 export type { EffectCrossProjectClientOptions } from './cross-project';
 export {
   HttpApi,
@@ -106,8 +103,7 @@ export type EffectRpcSerialization =
   | 'json'
   | 'ndjson'
   | 'jsonRpc'
-  | 'ndJsonRpc'
-  | 'msgPack';
+  | 'ndJsonRpc';
 
 export class EffectRpcClientError extends Data.TaggedError(
   'EffectRpcClientError',
@@ -138,8 +134,8 @@ export type EffectRpcClientHandle<
   Rpcs extends Rpc.Any,
   Flatten extends boolean = false,
 > = (Flatten extends true
-  ? RpcClient.RpcClient.Flat<Rpcs, unknown>
-  : RpcClient.RpcClient<Rpcs, unknown>) & {
+  ? RpcClient.RpcClient.Flat<Rpcs, RpcClientError.RpcClientError>
+  : RpcClient.RpcClient<Rpcs, RpcClientError.RpcClientError>) & {
   dispose: () => Promise<void>;
 };
 

package/src/microvertical-api.ts

@@ -48,7 +48,7 @@ export const MicroVerticalOperationSourceSchema = Schema.Literals([
   'client',
   'server',
   'generated-client',
-  'effect-adapter',
+  'effect-server',
   'data-platform',
   'unknown',
 ]);