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

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

@@ -1,13 +1,28 @@
 import "node:module";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { createEffectOperationContext, kEffectContextStorage } from "./operation-context.mjs";
 const globalStore = globalThis;
-const effectContextStorage = globalStore[kEffectContextStorage] ?? (globalStore[kEffectContextStorage] = new AsyncLocalStorage());
-const runWithEffectContext = (context, cb)=>effectContextStorage.run(context, cb);
+const asyncHooks = globalStore.process?.getBuiltinModule?.('node:async_hooks');
+const AsyncLocalStorage = asyncHooks?.AsyncLocalStorage;
+if ('function' != typeof AsyncLocalStorage) throw new Error('[BFF][Effect] The edge runtime must provide AsyncLocalStorage. Enable Node.js compatibility or the nodejs_als compatibility flag.');
+const EFFECT_BFF_CONTEXT_STORAGE_SHARE = '@modern-js/bff-effect/context-storage';
+let effectContextStorage = new AsyncLocalStorage();
+let effectContextStorageUsed = false;
+const usedEffectContextStorage = ()=>{
+    effectContextStorageUsed = true;
+    return effectContextStorage;
+};
+const runWithEffectContext = (context, cb)=>usedEffectContextStorage().run(context, cb);
 const useEffectContext = ()=>{
-    const context = effectContextStorage.getStore();
+    const context = usedEffectContextStorage().getStore();
     if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
     return context;
 };
+const getEffectContextStorage = ()=>effectContextStorage;
+function adoptEffectContextStorage(storage) {
+    const candidate = storage;
+    if ('function' != typeof candidate?.run || 'function' != typeof candidate.getStore) throw new Error(`[BFF][Effect] Share ${EFFECT_BFF_CONTEXT_STORAGE_SHARE} must provide an AsyncLocalStorage.`);
+    if (effectContextStorageUsed && candidate !== effectContextStorage) throw new Error('[BFF][Effect] A backend federation container received the host request storage after an Effect API already used its own. Evaluate exposes only after container init().');
+    effectContextStorage = candidate;
+}
 const useOperationContext = ()=>useEffectContext().operationContext;
-export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext };
+export { createEffectOperationContext } from "./operation-context.mjs";
+export { EFFECT_BFF_CONTEXT_STORAGE_SHARE, adoptEffectContextStorage, getEffectContextStorage, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm-node/effect/edge-dispatcher.mjs

@@ -1,14 +1,14 @@
 import "node:module";
+import { runWithEffectContext, useEffectContext, useOperationContext } from "@modern-js/bff-effect/context";
 import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/server-runtime-extensions/bff-policy";
 import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
 import { toHeaderRecord } from "../headers.mjs";
 import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
-import { runWithEffectContext, useEffectContext, useOperationContext } from "./edge-context.mjs";
 import { resolveEffectBffModuleHandler } from "./module.mjs";
 import * as __rspack_external_effect_Config_76cfa59d from "effect/Config";
-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";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
 const NORMALIZED_POLICY_BOOLEAN_FIELDS = [
     'enabled',
     'requireEnvelope',
@@ -108,9 +108,9 @@ async function createEffectBffEdgeHandler(options) {
         dispose: dispatcher.dispose
     };
 }
-export { Cookies, Etag, FetchHttpClient, FindMyWay, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpEffect, HttpIncomingMessage, HttpMethod, HttpMiddleware, HttpPlatform, HttpRouter, HttpServer, HttpServerError, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer, HttpStatus, HttpTraceContext, Multipart, MultipartParser, Template, Url, UrlParams } from "effect/unstable/http";
-export { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpApiTest, OpenApi } from "effect/unstable/httpapi";
-export { Rpc, RpcClient, RpcClientError, RpcGroup, RpcMessage, RpcMiddleware, RpcSchema, RpcSerialization, RpcServer, RpcTest, RpcWorker, Utils } from "effect/unstable/rpc";
+export { Cookies, Etag, FetchHttpClient, FindMyWay, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpEffect, HttpIncomingMessage, HttpMethod, HttpMiddleware, HttpPlatform, HttpRouter, HttpServer, HttpServerError, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer, HttpStatus, HttpTraceContext, Multipart, MultipartParser, Template, Url, UrlParams } from "effect/http";
+export { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpApiTest, OpenApi } from "effect/http-api";
+export { Rpc, RpcClient, RpcClientError, RpcGroup, RpcMessage, RpcMiddleware, RpcSchema, RpcSerialization, RpcServer, RpcTest, RpcWorker, Utils } from "effect/rpc";
 export { createHttpApiHandler, defineEffectBff, defineEffectRpcBff } from "./handler.mjs";
 export { createEffectOperationContext } from "./operation-context.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, createEffectBffEdgeDispatcher, createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm-node/effect/edge.mjs

@@ -1,3 +1,5 @@
 import "node:module";
 export * from "./edge-dispatcher.mjs";
+export { EFFECT_BFF_CONTEXT_STORAGE_SHARE } from "@modern-js/bff-effect/context";
+export { EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE, adoptEffectBffShareScope } from "./entry-shape.mjs";
 export { createEffectBffEdgeDispatcherFactory } from "./generated-entry.mjs";

package/dist/esm-node/effect/entry-shape.mjs

@@ -1,4 +1,6 @@
 import "node:module";
+import { EFFECT_BFF_CONTEXT_STORAGE_SHARE, adoptEffectContextStorage } from "@modern-js/bff-effect/context";
+const EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE = '@modern-js/bff-effect/handler-factory-registry';
 function createLocalValidatorAwareHandlerFactoryRegistry() {
     const factories = new WeakSet();
     return {
@@ -22,12 +24,33 @@ function loadNodeValidatorAwareHandlerFactoryRegistry() {
         throw error;
     }
 }
-const validatorAwareHandlerFactoryRegistry = loadNodeValidatorAwareHandlerFactoryRegistry();
+let validatorAwareHandlerFactoryRegistry;
+function handlerFactoryRegistry() {
+    validatorAwareHandlerFactoryRegistry ??= loadNodeValidatorAwareHandlerFactoryRegistry();
+    return validatorAwareHandlerFactoryRegistry;
+}
+const adoptShared = (shareScope, name, adopt)=>{
+    const versions = 'object' == typeof shareScope && null !== shareScope ? shareScope[name] : void 0;
+    const shared = void 0 === versions ? void 0 : Object.values(versions)[0];
+    if ('function' != typeof shared?.get) return Promise.resolve();
+    return Promise.resolve(shared.get()).then((factory)=>adopt('function' == typeof factory ? factory() : void 0));
+};
+function adoptEffectBffShareScope(shareScope) {
+    return Promise.all([
+        adoptShared(shareScope, EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE, (registry)=>adoptHandlerFactoryRegistry(registry)),
+        adoptShared(shareScope, EFFECT_BFF_CONTEXT_STORAGE_SHARE, adoptEffectContextStorage)
+    ]).then(()=>void 0);
+}
+function adoptHandlerFactoryRegistry(registry) {
+    if ('function' != typeof registry?.register || 'function' != typeof registry.is) throw new Error(`[BFF][Effect] Share ${EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE} must provide a handler factory registry.`);
+    if (void 0 !== validatorAwareHandlerFactoryRegistry && 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;
+}
 function registerValidatorAwareHandlerFactory(factory) {
-    return validatorAwareHandlerFactoryRegistry.register(factory);
+    return handlerFactoryRegistry().register(factory);
 }
 function isValidatorAwareHandlerFactory(factory) {
-    return validatorAwareHandlerFactoryRegistry.is(factory);
+    return handlerFactoryRegistry().is(factory);
 }
 const strictEffectApproachMessage = '[BFF][Effect] strictEffectApproach is enforced: Effect API entries export defineEffectBff(...) or { api, layer } HttpApi module. Raw handler exports, default request handlers, unbranded custom createHandler factories not valid Effect API entries.';
 function isEffectEntryRecord(value) {
@@ -60,4 +83,4 @@ function createEntryShapeFacts(module, predicates, unsupportedShape) {
         hasRuntimeLayer
     };
 }
-export { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, registerValidatorAwareHandlerFactory, strictEffectApproachMessage };
+export { EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE, adoptEffectBffShareScope, classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, registerValidatorAwareHandlerFactory, strictEffectApproachMessage };

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

@@ -1,7 +1,8 @@
 import "node:module";
 import { DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, decodeRequestEnvelopeHeader, isPlainObject, normalizeMethod } from "../../data-platform/index.mjs";
+import { normalizeBatchLimits } from "../../data-platform/batch/options.mjs";
 import { decodeBatchBody, isBatchBody, toBatchResponseItem } from "../../data-platform/batch/protocol.mjs";
-import { BatchItemTimeoutError, createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchAllowedMethods, normalizeBatchPath, promiseWithTimeout, toBatchItemError } from "./batch.mjs";
+import { BatchItemTimeoutError, createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchPath, promiseWithTimeout, toBatchItemError } from "./batch.mjs";
 import { getMountedPrefixFromContext, removeMountedPrefixFromBatchPath } from "./routing.mjs";
 import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
 const HOP_BY_HOP_BATCH_ITEM_HEADERS = new Set([
@@ -92,11 +93,9 @@ function createDataPlatformBatchRequestHandler(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 ?? 65536);
+    const { maxBatchSize: batchMaxSize, maxBatchBytes: batchMaxBytes, allowedMethods: batchAllowedMethods } = normalizeBatchLimits(dataPlatformBatchOptions);
     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 || DEFAULT_DATA_ENVELOPE_HEADER;
     const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
     const handle = async (request, context)=>{

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

@@ -7,12 +7,6 @@ function normalizeBatchPath(pathname) {
     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) && 2 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.sentAt && Array.isArray(value.items);
 }
@@ -110,4 +104,4 @@ async function mapWithConcurrency(items, concurrency, mapper) {
     return output;
 }
 export { toHeaderRecord } from "../../headers.mjs";
-export { BatchItemTimeoutError, createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchAllowedMethods, normalizeBatchPath, prepareJsonRequestBody, promiseWithTimeout, toBatchItemError };
+export { BatchItemTimeoutError, createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchPath, prepareJsonRequestBody, promiseWithTimeout, toBatchItemError };

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

@@ -1,5 +1,5 @@
 import "node:module";
-import { HttpRouter, HttpServer } from "effect/unstable/http";
+import { HttpRouter, HttpServer } from "effect/http";
 import { prepareJsonRequestBody } from "./batch.mjs";
 import { createDataPlatformBatchRequestHandler } from "./batch-handler.mjs";
 import { validateDataPlatformRequestEnvelope } from "./envelope.mjs";

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

@@ -1,6 +1,6 @@
 import "node:module";
-import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
-import { OpenApi } from "effect/unstable/httpapi";
+import { HttpRouter, HttpServerResponse } from "effect/http";
+import { OpenApi } from "effect/http-api";
 const DEFAULT_OPENAPI_PATH = '/openapi.json';
 function normalizeOpenApiPath(pathname) {
     if (!pathname.startsWith('/')) return `/${pathname}`;

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

@@ -1,6 +1,6 @@
 import "node:module";
-import { HttpRouter } from "effect/unstable/http";
-import { RpcServer } from "effect/unstable/rpc";
+import { HttpRouter } from "effect/http";
+import { RpcServer } from "effect/rpc";
 import { getRpcSerializationLayer } from "../rpcSerialization.mjs";
 import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
 function normalizeRpcPath(pathname) {

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

@@ -1,14 +1,14 @@
 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";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+export * from "effect/http";
+export * from "effect/http-api";
+export * from "effect/rpc";
+export { HttpTraceContext } from "effect/http";
+export { HttpApiBuilder } from "effect/http-api";
 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/effect/index.mjs

@@ -2,7 +2,7 @@ import "node:module";
 import * as __rspack_external__effect_opentelemetry_66324c75 from "@effect/opentelemetry";
 export * from "./endpoint-contracts.mjs";
 export * from "./handler.mjs";
-export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext } from "./context.mjs";
+export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext } from "@modern-js/bff-effect/context";
 export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest } from "./edge.mjs";
 export { resolveEffectBffModuleHandler } from "./module.mjs";
 export { __rspack_external__effect_opentelemetry_66324c75 as OpenTelemetry };

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

@@ -1,5 +1,5 @@
 import "node:module";
-import { HttpApi } from "effect/unstable/httpapi";
+import { HttpApi } from "effect/http-api";
 import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, strictEffectApproachMessage } from "./entry-shape.mjs";
 import { createHttpApiHandler } from "./handler.mjs";
 function isRequestHandler(value) {
@@ -43,6 +43,10 @@ function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
     if (facts.unsupportedShape) {
         if (rejectUnsupportedEffectModuleShape(options, facts.unsupportedShape)) return null;
     }
+    if (void 0 !== facts.module.rpc && !facts.createHandlerValidatorAware) {
+        rejectUnsupportedEffectModuleShape(options, 'unbranded RPC runtime');
+        return null;
+    }
     if ('function' == typeof facts.createHandler) {
         if (facts.createHandlerValidatorAware) {
             const factory = facts.createHandler;

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

@@ -1,6 +1,5 @@
 import "node:module";
 import { BFF_LOCALE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, BFF_TRACEPARENT_HEADER, parseTraceparent } from "@modern-js/runtime-extensions/request-context";
-const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
 const readHeader = (headers, header)=>{
     const value = headers.get(header);
     return value && value.length > 0 ? value : void 0;
@@ -55,7 +54,7 @@ const createEffectOperationContext = ({ request, path, method })=>{
         } : {},
         routePath: servicePath,
         method: (method || request.method || 'GET').toUpperCase(),
-        source: 'effect-adapter',
+        source: 'effect-server',
         ...path && path !== servicePath ? {
             attributes: {
                 mountedPath: path
@@ -73,4 +72,4 @@ const createEffectOperationContext = ({ request, path, method })=>{
         } : {}
     };
 };
-export { createEffectOperationContext, kEffectContextStorage };
+export { createEffectOperationContext };

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

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

package/dist/esm-node/effect-client/cross-project.mjs

@@ -1,7 +1,7 @@
 import "node:module";
-import { BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, resolveCrossProjectRequestObservation } from "@modern-js/server-runtime-extensions/bff-policy";
-import { HttpClient, HttpClientRequest } from "effect/unstable/http";
-import { HttpApi } from "effect/unstable/httpapi";
+import { BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, digestOperationContract, resolveCrossProjectRequestObservation } from "@modern-js/server-runtime-extensions/bff-policy";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { HttpApi } from "effect/http-api";
 import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
 import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
 const encodeJson = __rspack_external_effect_Schema_6065f72d.encodeSync(__rspack_external_effect_Schema_6065f72d.fromJsonString(__rspack_external_effect_Schema_6065f72d.Unknown));
@@ -31,14 +31,11 @@ function withCrossProjectPolicy(api, options, client) {
         const contract = observed && contracts[`${observed.method}:${observed.routePath}`];
         if (void 0 === contract) return __rspack_external_effect_Effect_41060786.die(new Error('[BFF][Effect] Request has no matching shared operation contract.'));
         return __rspack_external_effect_Effect_41060786.gen(function*() {
-            const input = encodeJson({
-                httpMethod: contract.method,
-                name: contract.name,
-                requestId: options.requestId,
-                routePath: contract.routePath
-            });
-            const digest = yield* __rspack_external_effect_Effect_41060786.promise(()=>globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(input)));
-            const schemaHash = Array.from(new Uint8Array(digest), (value)=>value.toString(16).padStart(2, '0')).join('');
+            const schemaHash = yield* __rspack_external_effect_Effect_41060786.promise(()=>digestOperationContract({
+                    httpMethod: contract.method,
+                    name: contract.name,
+                    routePath: contract.routePath
+                }, options.requestId));
             return request.pipe(HttpClientRequest.setHeader(BFF_ENVELOPE_HEADER, encodeJson({
                 requestId: options.requestId
             })), HttpClientRequest.setHeader(BFF_OPERATION_CONTEXT_HEADER, contract.operationId), HttpClientRequest.setHeader(BFF_OPERATION_CONTEXT_DETAIL_HEADER, encodeJson({

package/dist/esm-node/effect-client/index.mjs

@@ -1,14 +1,14 @@
 import "node:module";
 import { createRequestContextHeaders } from "@modern-js/runtime-extensions/request-context";
 import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
-import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
+import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from "effect/rpc";
 import { getRpcSerializationLayer } from "../effect/rpcSerialization.mjs";
 import { withCrossProjectPolicy } from "./cross-project.mjs";
+import * as __rspack_external_effect_http_HttpClientError_13c197e3 from "effect/http/HttpClientError";
 import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
-import * as __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 from "effect/unstable/http/HttpClientError";
 import * as __rspack_external_effect_Data_2b3f4efb from "effect/Data";
 import * as __rspack_external_effect_Exit_1ca64b33 from "effect/Exit";
 import * as __rspack_external_effect_ManagedRuntime_bfe218e3 from "effect/ManagedRuntime";
@@ -110,4 +110,4 @@ function makeEffectRpcClient(group, options) {
     });
 }
 const runEffectRequest = __rspack_external_effect_Effect_41060786.runPromise;
-export { EffectRpcClientError, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Schema_6065f72d as Schema, __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 as HttpClientError, makeEffectHttpApiClient, makeEffectRpcClient, mask, runEffectRequest, runEffectView, view };
+export { EffectRpcClientError, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Schema_6065f72d as Schema, __rspack_external_effect_http_HttpClientError_13c197e3 as HttpClientError, makeEffectHttpApiClient, makeEffectRpcClient, mask, runEffectRequest, runEffectView, view };

package/dist/esm-node/microvertical-api.mjs

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

package/dist/types/assembly.d.ts

@@ -1,10 +1,10 @@
 /** Server-only assembly for the invariant tail of a strict Effect BFF runtime factory. */
+import type { HttpApi, HttpApiGroup } from 'effect/http-api';
 import * as Layer from 'effect/Layer';
-import type { HttpApi, HttpApiGroup } from 'effect/unstable/httpapi';
 import type { EffectRuntimeRequirements } from './effect/handler/types.js';
 export interface EffectBffRuntimeAssembly<ApiId extends string, Groups extends HttpApiGroup.Constraint, HandlerRequirements extends EffectRuntimeRequirements, TransportRequirements extends EffectRuntimeRequirements = never> {
     readonly api: HttpApi.HttpApi<ApiId, Groups>;
     readonly handlers: Layer.Layer<HttpApiGroup.ToService<ApiId, Groups>, never, HandlerRequirements>;
     readonly transport?: Layer.Layer<never, never, TransportRequirements>;
 }
-export declare const assembleEffectBffRuntime: <ApiId extends string, Groups extends HttpApiGroup.Constraint, HandlerRequirements extends EffectRuntimeRequirements, TransportRequirements extends EffectRuntimeRequirements = never>({ api, handlers, transport, }: EffectBffRuntimeAssembly<ApiId, Groups, HandlerRequirements, TransportRequirements>) => import("./effect/index.js").EffectBffDefinition<HttpApi.HttpApi<ApiId, Groups>, Layer.Layer<never, never, HandlerRequirements | TransportRequirements | Exclude<import("effect/FileSystem").FileSystem, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/Etag").Generator, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/HttpPlatform").HttpPlatform, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/HttpRouter").HttpRouter, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/Path").Path, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<HttpApiGroup.ToService<ApiId, Groups>, HttpApiGroup.ToService<ApiId, Groups>>>, import("effect/unstable/rpc/Rpc").Any> & import("./effect/index.js").EffectBffRuntime<HttpApi.HttpApi<ApiId, Groups>, Layer.Layer<never, never, HandlerRequirements | TransportRequirements | Exclude<import("effect/FileSystem").FileSystem, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/Etag").Generator, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/HttpPlatform").HttpPlatform, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/HttpRouter").HttpRouter, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/Path").Path, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<HttpApiGroup.ToService<ApiId, Groups>, HttpApiGroup.ToService<ApiId, Groups>>>>;
+export declare const assembleEffectBffRuntime: <ApiId extends string, Groups extends HttpApiGroup.Constraint, HandlerRequirements extends EffectRuntimeRequirements, TransportRequirements extends EffectRuntimeRequirements = never>({ api, handlers, transport, }: EffectBffRuntimeAssembly<ApiId, Groups, HandlerRequirements, TransportRequirements>) => import("./effect/index.js").EffectBffDefinition<HttpApi.HttpApi<ApiId, Groups>, Layer.Layer<never, never, HandlerRequirements | TransportRequirements | Exclude<import("effect/FileSystem").FileSystem, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/http/Etag").Generator, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/http/HttpPlatform").HttpPlatform, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/http/HttpRouter").HttpRouter, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/Path").Path, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<HttpApiGroup.ToService<ApiId, Groups>, HttpApiGroup.ToService<ApiId, Groups>>>, import("effect/rpc/Rpc").Any> & import("./effect/index.js").EffectBffRuntime<HttpApi.HttpApi<ApiId, Groups>, Layer.Layer<never, never, HandlerRequirements | TransportRequirements | Exclude<import("effect/FileSystem").FileSystem, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/http/Etag").Generator, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/http/HttpPlatform").HttpPlatform, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/http/HttpRouter").HttpRouter, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/Path").Path, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<HttpApiGroup.ToService<ApiId, Groups>, HttpApiGroup.ToService<ApiId, Groups>>>>;

package/dist/types/data-platform/batch/options.d.ts

@@ -0,0 +1,7 @@
+import type { DataBatchTransportOptions } from '../types.js';
+/** Wire limits and method eligibility are identical on both sides. */
+export declare function normalizeBatchLimits(options?: Pick<DataBatchTransportOptions, 'maxBatchSize' | 'maxBatchBytes' | 'allowedMethods'>): {
+    maxBatchSize: number;
+    maxBatchBytes: number;
+    allowedMethods: Set<string>;
+};

package/dist/types/data-platform/batch/queue.d.ts

@@ -30,7 +30,6 @@ type QueuedBatchRequest = {
 };
 type BatchBucket = {
     items: QueuedBatchRequest[];
-    bytes: number;
     batchId: string;
     sentAt: number;
     timer: ReturnType<typeof setTimeout> | null;

package/dist/types/effect/context.d.ts

@@ -1,5 +1,18 @@
-import { type EffectContext } from './operation-context.js';
+import type { EffectContext, EffectContextStorage } from './operation-context.js';
 export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context.js';
+/**
+ * Module Federation share through which a backend federation host hands its
+ * request storage to the containers it initializes.
+ */
+export declare const EFFECT_BFF_CONTEXT_STORAGE_SHARE = "@modern-js/bff-effect/context-storage";
 export declare const runWithEffectContext: <T>(context: EffectContext, cb: () => T) => T;
 export declare const useEffectContext: () => EffectContext;
+/** @internal The storage a backend federation host shares with containers. */
+export declare const getEffectContextStorage: () => EffectContextStorage;
+/**
+ * @internal Called through `adoptEffectBffShareScope()` from a backend
+ * federation container's `init()`, so its endpoints read the context the
+ * host dispatcher enters.
+ */
+export declare function adoptEffectContextStorage(storage: unknown): void;
 export declare const useOperationContext: () => import("@modern-js/runtime-extensions/request-context").OperationContext;

package/dist/types/effect/edge-dispatcher.d.ts

@@ -3,15 +3,15 @@ import { type DispatchEffectBffRequestOptions } from './dispatch.js';
 import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions } from './handler.js';
 import { type EffectApiModule, type EffectBffRequestHandler } from './module.js';
 import type { EffectContext } from './operation-context.js';
+export { runWithEffectContext, useEffectContext, useOperationContext, } from './context.js';
 export * as Config from 'effect/Config';
 export * as Effect from 'effect/Effect';
+export { Cookies, Etag, FetchHttpClient, FindMyWay, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpEffect, HttpIncomingMessage, HttpMethod, HttpMiddleware, HttpPlatform, HttpRouter, HttpServer, HttpServerError, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer, HttpStatus, HttpTraceContext, Multipart, MultipartParser, Template, Url, UrlParams, } from 'effect/http';
+export { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpApiTest, OpenApi, } from 'effect/http-api';
 export * as Layer from 'effect/Layer';
 export * as Option from 'effect/Option';
+export { Rpc, RpcClient, RpcClientError, RpcGroup, RpcMessage, RpcMiddleware, RpcSchema, RpcSerialization, RpcServer, RpcTest, RpcWorker, Utils, } from 'effect/rpc';
 export * as Schema from 'effect/Schema';
-export { Cookies, Etag, FetchHttpClient, FindMyWay, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpEffect, HttpIncomingMessage, HttpMethod, HttpMiddleware, HttpPlatform, HttpRouter, HttpServer, HttpServerError, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer, HttpStatus, HttpTraceContext, Multipart, MultipartParser, Template, Url, UrlParams, } from 'effect/unstable/http';
-export { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpApiTest, OpenApi, } from 'effect/unstable/httpapi';
-export { Rpc, RpcClient, RpcClientError, RpcGroup, RpcMessage, RpcMiddleware, RpcSchema, RpcSerialization, RpcServer, RpcTest, RpcWorker, Utils, } from 'effect/unstable/rpc';
-export { runWithEffectContext, useEffectContext, useOperationContext, } from './edge-context.js';
 export type { EffectApiClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler.js';
 export { createHttpApiHandler, defineEffectBff, defineEffectRpcBff, } from './handler.js';
 export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context.js';

package/dist/types/effect/edge.d.ts

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

package/dist/types/effect/entry-shape.d.ts

@@ -1,6 +1,20 @@
+import type { EffectRpcBffDefinition } from './handler/types.js';
+/**
+ * Module Federation share through which a backend federation host hands its
+ * package-private handler factory registry to the containers it initializes.
+ */
+export declare const EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE = "@modern-js/bff-effect/handler-factory-registry";
+/**
+ * @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 declare function adoptEffectBffShareScope(shareScope: unknown): Promise<void>;
 type EffectBffEntryModule = {
     api?: unknown;
     layer?: unknown;
+    rpc?: EffectRpcBffDefinition;
     handler?: unknown;
     createHandler?: unknown;
     default?: unknown;

package/dist/types/effect/handler/batch.d.ts

@@ -1,7 +1,6 @@
 import { type DataBatchRequestPayload, type DataBatchResponseItem } from '../../data-platform/index.js';
 export { toHeaderRecord } from '../../headers.js';
 export declare function normalizeBatchPath(pathname: string | undefined): `/${string}`;
-export declare function normalizeBatchAllowedMethods(allowedMethods: string[] | undefined): Set<string>;
 type ParsedBatchRequestPayload = Omit<DataBatchRequestPayload, 'items'> & {
     items: unknown[];
 };

package/dist/types/effect/handler/definition.d.ts

@@ -1,5 +1,5 @@
-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 type { EffectBffDefinition, EffectBffRuntime, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcRuntimeLayer, EffectRuntimeLayer } from './types.js';
 export declare function defineEffectBff<TApi extends HttpApi.Constraint, TLayer extends EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any>(definition: EffectBffDefinition<TApi, TLayer, TRpcs>): EffectBffDefinition<TApi, TLayer, TRpcs> & EffectBffRuntime<TApi, TLayer>;
 export declare function defineEffectRpcBff<TRpcs extends Rpc.Any = Rpc.Any, TLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>>(definition: EffectRpcBffDefinition<TRpcs, TLayer>): EffectRpcBffDefinition<TRpcs, TLayer> & {

package/dist/types/effect/handler/http.d.ts

@@ -1,5 +1,5 @@
-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 type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestInterceptor, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types.js';
 export declare function createHttpApiHandler<TApi extends HttpApi.Constraint = HttpApi.Top, TRpcs extends Rpc.Any = Rpc.Any>(options: {
     api: TApi;

package/dist/types/effect/handler/openapi.d.ts

@@ -1,4 +1,4 @@
-import { HttpRouter } from 'effect/unstable/http';
-import { type HttpApi } from 'effect/unstable/httpapi';
+import { HttpRouter } from 'effect/http';
+import { type HttpApi } from 'effect/http-api';
 import type { EffectBffOpenApiConfig } from './types.js';
 export declare function createOpenApiLayer(api: HttpApi.Constraint, openapi: EffectBffOpenApiConfig | undefined): import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter> | null;

package/dist/types/effect/handler/rpc.d.ts

@@ -1,4 +1,4 @@
-import { type Rpc } from 'effect/unstable/rpc';
+import { type Rpc } from 'effect/rpc';
 import type { EffectRpcBffDefinition } from './types.js';
 export declare function normalizeRpcPath(pathname: string | undefined): `/${string}`;
 export declare function createRpcApiHandler<TRpcs extends Rpc.Any = Rpc.Any>(options: EffectRpcBffDefinition<TRpcs>): {

package/dist/types/effect/handler/types.d.ts

@@ -1,15 +1,15 @@
 import type { FileSystem, Path } from 'effect';
 import * as Context from 'effect/Context';
+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.js';
 import type { createRpcApiHandler } from './rpc.js';
 export type EffectRuntimeRequirements = Etag.Generator | FileSystem.FileSystem | HttpPlatform.HttpPlatform | HttpRouter.HttpRouter | HttpRouter.Request<'Error', unknown> | HttpRouter.Request<'GlobalError', unknown> | HttpRouter.Request<'GlobalRequires', unknown> | HttpRouter.Request<'Requires', unknown> | Path.Path;
 export type EffectRuntimeLayer = Layer.Layer<never, never, EffectRuntimeRequirements>;
 export declare const toEffectServiceContext: (context: unknown) => Context.Context<any>;
-export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
+export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc';
 export type EffectRpcRuntimeLayer<TRpcs extends Rpc.Any = Rpc.Any> = Layer.Layer<Rpc.ToHandler<TRpcs> | Rpc.Middleware<TRpcs> | Rpc.ServicesServer<TRpcs>, unknown, never>;
 export type EffectRpcBffDefinition<TRpcs extends Rpc.Any = Rpc.Any, TRpcLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>> = {
     group: RpcGroup.RpcGroup<TRpcs>;
@@ -123,7 +123,7 @@ export type EffectRequestInterceptor = (options: {
     request: Request;
     next: () => Promise<Response>;
 }) => Response | Promise<Response>;
-export type EffectBffHandlerFactory<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
+export type EffectBffHandlerFactory<_TApi extends HttpApi.Constraint = HttpApi.Top, _TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
     openapi?: EffectBffOpenApiConfig;
     rpc?: Partial<EffectRpcBffHandlerOptions>;
     dataPlatform?: Partial<EffectDataPlatformValidationOptions>;

package/dist/types/effect/handler.d.ts

@@ -1,13 +1,13 @@
 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.js';
 export { createHttpApiHandler } from './handler/http.js';
 export type { EffectApiClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler/types.js';

package/dist/types/effect/module.d.ts

@@ -1,5 +1,5 @@
 import type * as EffectServiceContext from 'effect/Context';
-import { type EffectBffOpenApiConfig, type EffectDataPlatformValidationOptions, type EffectRequestValidator } from './handler.js';
+import { type EffectBffOpenApiConfig, type EffectDataPlatformValidationOptions, type EffectRequestValidator, type EffectRpcBffDefinition } from './handler.js';
 import type { EffectContext } from './operation-context.js';
 export type EffectBffRequestHandler = (request: Request, context?: EffectServiceContext.Context<any> | EffectContext) => Promise<Response> | Response;
 export type EffectBffHandlerFactory = (options?: {
@@ -13,6 +13,7 @@ export type EffectBffHandlerFactory = (options?: {
 export type EffectApiModule = {
     api?: unknown;
     layer?: unknown;
+    rpc?: EffectRpcBffDefinition;
     handler?: EffectBffRequestHandler;
     createHandler?: EffectBffHandlerFactory;
     default?: unknown;

package/dist/types/effect/operation-context.d.ts

@@ -10,6 +10,5 @@ export type EffectContextStorage = {
     getStore: () => EffectContext | undefined;
     run: <TResult>(value: EffectContext, cb: () => TResult) => TResult;
 };
-export declare const kEffectContextStorage: unique symbol;
 export type CreateEffectOperationContextOptions = Omit<EffectContext, 'operationContext'>;
 export declare const createEffectOperationContext: ({ request, path, method, }: CreateEffectOperationContextOptions) => OperationContext;

package/dist/types/effect/rpcSerialization.d.ts

@@ -1,3 +1,3 @@
-import { RpcSerialization } from 'effect/unstable/rpc';
+import { RpcSerialization } from 'effect/rpc';
 import type { EffectRpcSerialization } from './handler/types.js';
 export declare function getRpcSerializationLayer(serialization: EffectRpcSerialization | undefined): import("effect/Layer").Layer<RpcSerialization.RpcSerialization, never, never>;

package/dist/types/effect-client/cross-project.d.ts

@@ -1,5 +1,5 @@
-import { HttpClient } from 'effect/unstable/http';
-import { HttpApi, type HttpApiGroup } from 'effect/unstable/httpapi';
+import { HttpClient } from 'effect/http';
+import { HttpApi, type HttpApiGroup } from 'effect/http-api';
 export interface EffectCrossProjectClientOptions {
     requestId: string;
     operationVersion: number;