@bleedingdev/modern-js-bff-effect 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

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/module.mjs

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

@@ -55,7 +55,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

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

@@ -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,5 +1,5 @@
 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 { 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/unstable/http";
 import { HttpApi } from "effect/unstable/httpapi";
 import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
@@ -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/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/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/entry-shape.d.ts

@@ -1,6 +1,8 @@
+import type { EffectRpcBffDefinition } from './handler/types.js';
 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/types.d.ts

@@ -9,7 +9,7 @@ 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>;

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-client/index.d.ts

@@ -3,7 +3,7 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import { HttpClient } 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, RpcClientError, RpcGroup, RpcSchema, RpcSerialization } from 'effect/unstable/rpc';
 import { type EffectCrossProjectClientOptions } from './cross-project.js';
 export * as Effect from 'effect/Effect';
 export * as Layer from 'effect/Layer';
@@ -30,7 +30,7 @@ export type EffectViewSelection<T> = {
 export type EffectViewData<T, Selection> = Selection extends true ? T : Selection extends Record<string, unknown> ? {
     [K in keyof Selection & keyof T]: EffectMaskedValue<T[K], Selection[K]>;
 } : T;
-export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
+export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc';
 declare const EffectRpcClientError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "EffectRpcClientError";
 } & Readonly<A>;
@@ -50,7 +50,7 @@ export type EffectRpcClientOptions<Rpcs extends Rpc.Any, Flatten extends boolean
     flatten?: Flatten;
     serialization?: EffectRpcSerialization;
 };
-export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean = false> = (Flatten extends true ? RpcClient.RpcClient.Flat<Rpcs, unknown> : RpcClient.RpcClient<Rpcs, unknown>) & {
+export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean = false> = (Flatten extends true ? RpcClient.RpcClient.Flat<Rpcs, RpcClientError.RpcClientError> : RpcClient.RpcClient<Rpcs, RpcClientError.RpcClientError>) & {
     dispose: () => Promise<void>;
 };
 export declare function view<T>(): <const Selection extends EffectViewSelection<T>>(selection: Selection) => Selection;

package/dist/types/microvertical-api.d.ts

@@ -33,13 +33,13 @@ export declare const MicroVerticalReadinessSchema: Schema.Struct<{
     readonly versionSkew: Schema.Literal<"none">;
 }>;
 export type MicroVerticalReadiness = typeof MicroVerticalReadinessSchema.Type;
-export declare const MicroVerticalOperationSourceSchema: Schema.Literals<readonly ["client", "server", "generated-client", "effect-adapter", "data-platform", "unknown"]>;
+export declare const MicroVerticalOperationSourceSchema: Schema.Literals<readonly ["client", "server", "generated-client", "effect-server", "data-platform", "unknown"]>;
 export type MicroVerticalOperationSource = typeof MicroVerticalOperationSourceSchema.Type;
 export declare const MicroVerticalOperationContextSchema: Schema.Struct<{
     readonly method: Schema.String;
     readonly operationId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalOperationId">>;
     readonly routePath: Schema.String;
-    readonly source: Schema.Literals<readonly ["client", "server", "generated-client", "effect-adapter", "data-platform", "unknown"]>;
+    readonly source: Schema.Literals<readonly ["client", "server", "generated-client", "effect-server", "data-platform", "unknown"]>;
     readonly traceId: Schema.optionalKey<Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalTraceId">>>;
 }>;
 export type MicroVerticalOperationContext = typeof MicroVerticalOperationContextSchema.Type;
@@ -55,11 +55,11 @@ export declare const microVerticalOperationAttributes: (operationContext: MicroV
     'modernjs.operation.id': string;
     'modernjs.operation.method': string;
     'modernjs.operation.route': string;
-    'modernjs.operation.source': "client" | "data-platform" | "effect-adapter" | "generated-client" | "server" | "unknown";
+    'modernjs.operation.source': "client" | "data-platform" | "effect-server" | "generated-client" | "server" | "unknown";
 } | {
     'modernjs.operation.id': string;
     'modernjs.operation.method': string;
     'modernjs.operation.route': string;
-    'modernjs.operation.source': "client" | "data-platform" | "effect-adapter" | "generated-client" | "server" | "unknown";
+    'modernjs.operation.source': "client" | "data-platform" | "effect-server" | "generated-client" | "server" | "unknown";
     'modernjs.trace.id': string;
 };

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "ultramodern.js"
   ],
-  "version": "3.9.0-ultramodern.11",
+  "version": "3.9.0-ultramodern.13",
   "files": [
     "dist",
     "src"
@@ -130,10 +130,10 @@
     "node": ">=26.7.0"
   },
   "dependencies": {
-    "@modern-js/bff-core": "npm:@bleedingdev/modern-js-bff-core@3.9.0-ultramodern.11",
-    "@modern-js/create-request": "npm:@bleedingdev/modern-js-create-request@3.9.0-ultramodern.11",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.11",
-    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.11",
+    "@modern-js/bff-core": "npm:@bleedingdev/modern-js-bff-core@3.9.0-ultramodern.13",
+    "@modern-js/create-request": "npm:@bleedingdev/modern-js-create-request@3.9.0-ultramodern.13",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.13",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.13",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/api-logs": "0.222.0",
     "@opentelemetry/resources": "2.11.0",
@@ -145,8 +145,8 @@
     "@opentelemetry/semantic-conventions": "1.43.0"
   },
   "peerDependencies": {
-    "@effect/opentelemetry": "4.0.0-rc.112",
-    "effect": "4.0.0-rc.112"
+    "@effect/opentelemetry": "4.0.0-rc.117",
+    "effect": "4.0.0-rc.117"
   },
   "peerDependenciesMeta": {
     "@effect/opentelemetry": {
@@ -157,13 +157,13 @@
     }
   },
   "devDependencies": {
-    "@effect/opentelemetry": "4.0.0-rc.112",
-    "@rslib/core": "1.0.0",
+    "@effect/opentelemetry": "4.0.0-rc.117",
+    "@rslib/core": "1.0.2",
     "@scripts/rstest-config": "2.66.0",
-    "@types/node": "^26.4.1",
-    "@types/react": "^19.2.18",
+    "@types/node": "^26.6.2",
+    "@types/react": "^19.3.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "effect": "4.0.0-rc.112"
+    "effect": "npm:@bleedingdev/effect@4.0.0-rc.117"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/data-platform/batch/options.ts

@@ -0,0 +1,20 @@
+import type { DataBatchTransportOptions } from '../types';
+
+/** Wire limits and method eligibility are identical on both sides. */
+export function normalizeBatchLimits(
+  options: Pick<
+    DataBatchTransportOptions,
+    'maxBatchSize' | 'maxBatchBytes' | 'allowedMethods'
+  > = {},
+) {
+  return {
+    maxBatchSize: Math.max(1, options.maxBatchSize ?? 16),
+    maxBatchBytes: Math.max(1024, options.maxBatchBytes ?? 64 * 1024),
+    allowedMethods: new Set(
+      (options.allowedMethods !== undefined && options.allowedMethods.length > 0
+        ? options.allowedMethods
+        : ['GET']
+      ).map(method => method.toUpperCase()),
+    ),
+  };
+}

package/src/data-platform/batch/queue.ts

@@ -8,6 +8,7 @@ import type {
   DataTransportRequestInfo,
 } from '../types';
 import { DEFAULT_DATA_BATCH_HEADER } from '../types';
+import { normalizeBatchLimits } from './options';
 import { decodeBatchBody, isNullBodyStatus } from './protocol';
 import {
   createBatchId,
@@ -37,6 +38,9 @@ type NormalizedBatchTransportRequest = {
   endpoint: string;
   method: string;
   headers: Record<string, string>;
+  itemHeaders: Record<string, string>;
+  bucketKey: string;
+  itemPath: string;
   credentials: RequestCredentials;
   body: BodyInit | null;
   hasOpaqueSourceBody: boolean;
@@ -76,7 +80,6 @@ type QueuedBatchRequest = {
 
 type BatchBucket = {
   items: QueuedBatchRequest[];
-  bytes: number;
   batchId: string;
   sentAt: number;
   timer: ReturnType<typeof setTimeout> | null;
@@ -185,7 +188,6 @@ export class BatchBucketRegistry {
 
     const next: BatchBucket = {
       items: [],
-      bytes: 0,
       batchId: createBatchId(),
       sentAt: Date.now(),
       timer: null,
@@ -215,15 +217,9 @@ export function createBatchTransportQueue({
   bucketRegistry,
 }: CreateBatchTransportQueueOptions) {
   const flushIntervalMs = Math.max(0, options.flushIntervalMs ?? 8);
-  const maxBatchSize = Math.max(1, options.maxBatchSize ?? 16);
-  const maxBatchBytes = Math.max(1024, options.maxBatchBytes ?? 64 * 1024);
+  const { maxBatchSize, maxBatchBytes, allowedMethods } =
+    normalizeBatchLimits(options);
   const requestTimeoutMs = options.requestTimeoutMs;
-  const allowedMethods = new Set(
-    (options.allowedMethods && options.allowedMethods.length > 0
-      ? options.allowedMethods
-      : ['GET']
-    ).map(method => method.toUpperCase()),
-  );
   const onEvent = options.onEvent;
 
   const buckets = bucketRegistry ?? new BatchBucketRegistry();
@@ -284,7 +280,6 @@ export function createBatchTransportQueue({
       return;
     }
     bucket.items.splice(index, 1);
-    bucket.bytes = measurePayload(bucket, bucket.items);
     if (bucket.items.length === 0 && bucket.timer) {
       clearTimeout(bucket.timer);
       bucket.timer = null;
@@ -347,11 +342,11 @@ export function createBatchTransportQueue({
     return runSingle(request);
   };
 
-  const settleAmbiguousBatchRequests = (
-    items: QueuedBatchRequest[],
-    reason: string,
-  ) =>
-    settleRequests(items, request => runAfterAmbiguousBatch(request, reason));
+  const finishFlush = (bucketKey: string, bucket: BatchBucket) => {
+    bucket.flushing = false;
+    if (bucket.items.length > 0 && !bucket.timer) void flushBucket(bucketKey);
+    buckets.releaseIfIdle(bucketKey, bucket);
+  };
 
   const flushBucket = async (bucketKey: string) => {
     const bucket = buckets.get(bucketKey);
@@ -379,7 +374,6 @@ export function createBatchTransportQueue({
       sentAt: bucket.sentAt,
     };
     bucket.items = [];
-    bucket.bytes = 0;
     rotatePayloadIdentity(bucket);
     const firstItem = items[0];
     if (!firstItem) {
@@ -396,17 +390,28 @@ export function createBatchTransportQueue({
         size: items.length,
         reason: disabledEndpoints.has(endpoint) ? 'batch-disabled' : undefined,
       });
-      await settleRequests(items, runSingle);
-      bucket.flushing = false;
-      if (bucket.items.length > 0 && !bucket.timer) {
-        void flushBucket(bucketKey);
+      try {
+        await settleRequests(items, runSingle);
+      } finally {
+        finishFlush(bucketKey, bucket);
       }
-      buckets.releaseIfIdle(bucketKey, bucket);
       return;
     }
 
     const payload = createPayload(payloadIdentity, items);
     const batchId = payload.batchId;
+    const settleAmbiguousBatchRequests = (reason: string) => {
+      emitDataBatchTransportEvent(onEvent, {
+        type: 'fallback',
+        endpoint,
+        batchId,
+        size: items.length,
+        reason,
+      });
+      return settleRequests(items, request =>
+        runAfterAmbiguousBatch(request, reason),
+      );
+    };
 
     emitDataBatchTransportEvent(onEvent, {
       type: 'flush',
@@ -473,20 +478,17 @@ export function createBatchTransportQueue({
             batchId,
             reason: `batch-endpoint-unavailable-${String(response.status)}`,
           });
+          await settleRequests(items, request =>
+            runAfterAmbiguousBatch(
+              request,
+              `batch-response-${String(response.status)}`,
+            ),
+          );
         } else {
-          emitDataBatchTransportEvent(onEvent, {
-            type: 'fallback',
-            endpoint,
-            batchId,
-            size: items.length,
-            reason: `batch-response-${String(response.status)}`,
-          });
+          await settleAmbiguousBatchRequests(
+            `batch-response-${String(response.status)}`,
+          );
         }
-        await settleAmbiguousBatchRequests(
-          items,
-          `batch-response-${String(response.status)}`,
-        );
-        bucket.flushing = false;
         return;
       }
 
@@ -494,28 +496,12 @@ export function createBatchTransportQueue({
         response.json(),
       );
       if (!isBatchResponsePayload(result)) {
-        emitDataBatchTransportEvent(onEvent, {
-          type: 'fallback',
-          endpoint,
-          batchId,
-          size: items.length,
-          reason: 'invalid-batch-response',
-        });
-        await settleAmbiguousBatchRequests(items, 'invalid-batch-response');
-        bucket.flushing = false;
+        await settleAmbiguousBatchRequests('invalid-batch-response');
         return;
       }
 
       if (result.batchId !== batchId) {
-        emitDataBatchTransportEvent(onEvent, {
-          type: 'fallback',
-          endpoint,
-          batchId,
-          size: items.length,
-          reason: 'mismatched-batch-id',
-        });
-        await settleAmbiguousBatchRequests(items, 'mismatched-batch-id');
-        bucket.flushing = false;
+        await settleAmbiguousBatchRequests('mismatched-batch-id');
         return;
       }
 
@@ -555,23 +541,12 @@ export function createBatchTransportQueue({
         }
         return;
       }
-      emitDataBatchTransportEvent(onEvent, {
-        type: 'fallback',
-        endpoint,
-        batchId,
-        size: items.length,
-        reason: 'batch-transport-error',
-      });
-      await settleAmbiguousBatchRequests(items, 'batch-transport-error');
+      await settleAmbiguousBatchRequests('batch-transport-error');
     } finally {
       for (const item of items) {
         item.abortBatchIfUnused = undefined;
       }
-      bucket.flushing = false;
-      if (bucket.items.length > 0 && !bucket.timer) {
-        void flushBucket(bucketKey);
-      }
-      buckets.releaseIfIdle(bucketKey, bucket);
+      finishFlush(bucketKey, bucket);
     }
   };
 
@@ -617,7 +592,18 @@ export function createBatchTransportQueue({
       options.endpoint,
     ).toString();
 
+    const itemHeaders = { ...headers };
+    delete itemHeaders.authorization;
+    delete itemHeaders.cookie;
     return {
+      itemHeaders,
+      itemPath: `${requestUrl.pathname}${requestUrl.search}`,
+      bucketKey: stableStringify({
+        endpoint,
+        authorization: headers.authorization ?? null,
+        cookie: headers.cookie ?? null,
+        credentials,
+      }),
       requestUrl,
       endpoint,
       method,
@@ -660,20 +646,11 @@ export function createBatchTransportQueue({
       return undefined;
     }
 
-    const itemHeaders = { ...request.headers };
-    delete itemHeaders.authorization;
-    delete itemHeaders.cookie;
-    const bucketKey = stableStringify({
-      endpoint: request.endpoint,
-      authorization: request.headers.authorization ?? null,
-      cookie: request.headers.cookie ?? null,
-      credentials: request.credentials,
-    });
     return stableStringify({
-      bucketKey,
-      path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+      bucketKey: request.bucketKey,
+      path: request.itemPath,
       method: request.method,
-      headers: itemHeaders,
+      headers: request.itemHeaders,
       body: null,
     });
   };
@@ -704,9 +681,7 @@ export function createBatchTransportQueue({
       .slice(2, 8)}`;
     nextItemId += 1;
 
-    const itemHeaders = { ...request.headers };
-    delete itemHeaders.authorization;
-    delete itemHeaders.cookie;
+    const itemHeaders = { ...request.itemHeaders };
     if (
       preparedBody.body &&
       preparedBody.inferredContentType &&
@@ -716,18 +691,13 @@ export function createBatchTransportQueue({
     }
     const item: DataBatchRequestItem = {
       id: itemId,
-      path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+      path: request.itemPath,
       method: request.method,
       headers: itemHeaders,
       ...(preparedBody.body ? { body: preparedBody.body } : {}),
     };
 
-    const bucketKey = stableStringify({
-      endpoint: request.endpoint,
-      authorization: request.headers.authorization ?? null,
-      cookie: request.headers.cookie ?? null,
-      credentials: request.credentials,
-    });
+    const { bucketKey } = request;
 
     const key = stableStringify({
       bucketKey,
@@ -824,14 +794,16 @@ export function createBatchTransportQueue({
     }
 
     bucket.items.push(queued);
-    bucket.bytes = measurePayload(bucket, bucket.items);
     emitDataBatchTransportEvent(onEvent, {
       type: 'enqueue',
       endpoint: request.endpoint,
       size: bucket.items.length,
     });
 
-    if (bucket.items.length >= maxBatchSize || bucket.bytes >= maxBatchBytes) {
+    if (
+      bucket.items.length >= maxBatchSize ||
+      measurePayload(bucket, bucket.items) >= maxBatchBytes
+    ) {
       void flushBucket(bucketKey);
       return queued.promise;
     }

package/src/effect/entry-shape.ts

@@ -1,8 +1,14 @@
+import type { EffectRpcBffDefinition } from './handler/types';
+
 type ValidatorAwareHandlerFactoryRegistry = {
   register<TFactory extends Function>(factory: TFactory): TFactory;
   is(factory: unknown): boolean;
 };
 
+declare const __modernjs_backend_private_capability__:
+  | ValidatorAwareHandlerFactoryRegistry
+  | undefined;
+
 function createLocalValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandlerFactoryRegistry {
   const factories = new WeakSet<Function>();
   return {
@@ -19,6 +25,11 @@ function createLocalValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandle
 function loadNodeValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandlerFactoryRegistry {
   const moduleUrl = import.meta.url;
   if (typeof moduleUrl !== 'string' || !moduleUrl.startsWith('file:')) {
+    // A verified CommonJS backend bundle has no import.meta.url. Its Node
+    // evaluator supplies the package-private registry directly.
+    if (typeof __modernjs_backend_private_capability__ !== 'undefined') {
+      return __modernjs_backend_private_capability__;
+    }
     return createLocalValidatorAwareHandlerFactoryRegistry();
   }
 
@@ -53,6 +64,7 @@ const validatorAwareHandlerFactoryRegistry =
 type EffectBffEntryModule = {
   api?: unknown;
   layer?: unknown;
+  rpc?: EffectRpcBffDefinition;
   handler?: unknown;
   createHandler?: unknown;
   default?: unknown;