@bleedingdev/modern-js-bff-effect 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/cjs/effect/handler/openapi.js

@@ -30,8 +30,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createOpenApiLayer: ()=>createOpenApiLayer
 });
-const http_namespaceObject = require("effect/unstable/http");
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const http_namespaceObject = require("effect/http");
+const http_api_namespaceObject = require("effect/http-api");
 const DEFAULT_OPENAPI_PATH = '/openapi.json';
 function normalizeOpenApiPath(pathname) {
     if (!pathname.startsWith('/')) return `/${pathname}`;
@@ -47,7 +47,7 @@ function getOpenApiOptions(openapi) {
 function createOpenApiLayer(api, openapi) {
     const openApiOptions = getOpenApiOptions(openapi);
     if (!openApiOptions) return null;
-    return http_namespaceObject.HttpRouter.add('GET', openApiOptions.path, http_namespaceObject.HttpServerResponse.jsonUnsafe(httpapi_namespaceObject.OpenApi.fromApi(api)));
+    return http_namespaceObject.HttpRouter.add('GET', openApiOptions.path, http_namespaceObject.HttpServerResponse.jsonUnsafe(http_api_namespaceObject.OpenApi.fromApi(api)));
 }
 exports.createOpenApiLayer = __webpack_exports__.createOpenApiLayer;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/effect/handler/rpc.js

@@ -31,9 +31,9 @@ __webpack_require__.d(__webpack_exports__, {
     createRpcApiHandler: ()=>createRpcApiHandler,
     normalizeRpcPath: ()=>normalizeRpcPath
 });
+const http_namespaceObject = require("effect/http");
 const Layer_namespaceObject = require("effect/Layer");
-const http_namespaceObject = require("effect/unstable/http");
-const rpc_namespaceObject = require("effect/unstable/rpc");
+const rpc_namespaceObject = require("effect/rpc");
 const external_rpcSerialization_js_namespaceObject = require("../rpcSerialization.js");
 function normalizeRpcPath(pathname) {
     if (!pathname || '/' === pathname) return '/rpc';

package/dist/cjs/effect/handler.js

@@ -21,14 +21,14 @@ var __webpack_modules__ = {
     "effect/Schema" (module) {
         module.exports = require("effect/Schema");
     },
-    "effect/unstable/http" (module) {
-        module.exports = require("effect/unstable/http");
+    "effect/http" (module) {
+        module.exports = require("effect/http");
     },
-    "effect/unstable/httpapi" (module) {
-        module.exports = require("effect/unstable/httpapi");
+    "effect/http-api" (module) {
+        module.exports = require("effect/http-api");
     },
-    "effect/unstable/rpc" (module) {
-        module.exports = require("effect/unstable/rpc");
+    "effect/rpc" (module) {
+        module.exports = require("effect/rpc");
     }
 };
 var __webpack_module_cache__ = {};
@@ -80,16 +80,13 @@ var __webpack_exports__ = {};
     __webpack_require__.r(__webpack_exports__);
     var effect_Config__rspack_import_0 = __webpack_require__("effect/Config");
     var effect_Effect__rspack_import_1 = __webpack_require__("effect/Effect");
-    var effect_Layer__rspack_import_2 = __webpack_require__("effect/Layer");
-    var effect_Option__rspack_import_3 = __webpack_require__("effect/Option");
-    var effect_Schema__rspack_import_4 = __webpack_require__("effect/Schema");
-    var effect_unstable_http__rspack_import_5 = __webpack_require__("effect/unstable/http");
+    var effect_http__rspack_import_2 = __webpack_require__("effect/http");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in effect_unstable_http__rspack_import_5)if ([
+    for(const __rspack_import_key in effect_http__rspack_import_2)if ([
         "Config",
+        "HttpTraceContext",
         "Layer",
         "Schema",
-        "HttpTraceContext",
         "HttpApiBuilder",
         "defineEffectBff",
         "default",
@@ -97,15 +94,15 @@ var __webpack_exports__ = {};
         "defineEffectRpcBff",
         "createHttpApiHandler",
         "Option"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_http__rspack_import_5[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_http__rspack_import_2[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var effect_unstable_httpapi__rspack_import_6 = __webpack_require__("effect/unstable/httpapi");
+    var effect_http_api__rspack_import_3 = __webpack_require__("effect/http-api");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in effect_unstable_httpapi__rspack_import_6)if ([
+    for(const __rspack_import_key in effect_http_api__rspack_import_3)if ([
         "Config",
+        "HttpTraceContext",
         "Layer",
         "Schema",
-        "HttpTraceContext",
         "HttpApiBuilder",
         "defineEffectBff",
         "default",
@@ -113,15 +110,17 @@ var __webpack_exports__ = {};
         "defineEffectRpcBff",
         "createHttpApiHandler",
         "Option"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_httpapi__rspack_import_6[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_http_api__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var effect_unstable_rpc__rspack_import_7 = __webpack_require__("effect/unstable/rpc");
+    var effect_Layer__rspack_import_4 = __webpack_require__("effect/Layer");
+    var effect_Option__rspack_import_5 = __webpack_require__("effect/Option");
+    var effect_rpc__rspack_import_6 = __webpack_require__("effect/rpc");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in effect_unstable_rpc__rspack_import_7)if ([
+    for(const __rspack_import_key in effect_rpc__rspack_import_6)if ([
         "Config",
+        "HttpTraceContext",
         "Layer",
         "Schema",
-        "HttpTraceContext",
         "HttpApiBuilder",
         "defineEffectBff",
         "default",
@@ -129,18 +128,19 @@ var __webpack_exports__ = {};
         "defineEffectRpcBff",
         "createHttpApiHandler",
         "Option"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_rpc__rspack_import_7[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_rpc__rspack_import_6[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var effect_Schema__rspack_import_7 = __webpack_require__("effect/Schema");
     var _handler_definition__rspack_import_8 = __webpack_require__("./handler/definition");
     var _handler_http__rspack_import_9 = __webpack_require__("./handler/http");
     __webpack_require__.d(__webpack_exports__, {
         Config: ()=>effect_Config__rspack_import_0,
         Effect: ()=>effect_Effect__rspack_import_1,
-        HttpApiBuilder: ()=>effect_unstable_httpapi__rspack_import_6.HttpApiBuilder,
-        HttpTraceContext: ()=>effect_unstable_http__rspack_import_5.HttpTraceContext,
-        Layer: ()=>effect_Layer__rspack_import_2,
-        Option: ()=>effect_Option__rspack_import_3,
-        Schema: ()=>effect_Schema__rspack_import_4,
+        HttpApiBuilder: ()=>effect_http_api__rspack_import_3.HttpApiBuilder,
+        HttpTraceContext: ()=>effect_http__rspack_import_2.HttpTraceContext,
+        Layer: ()=>effect_Layer__rspack_import_4,
+        Option: ()=>effect_Option__rspack_import_5,
+        Schema: ()=>effect_Schema__rspack_import_7,
         createHttpApiHandler: ()=>_handler_http__rspack_import_9.createHttpApiHandler,
         defineEffectBff: ()=>_handler_definition__rspack_import_8.defineEffectBff,
         defineEffectRpcBff: ()=>_handler_definition__rspack_import_8.defineEffectRpcBff

package/dist/cjs/effect/index.js

@@ -1,8 +1,5 @@
 "use strict";
 var __webpack_modules__ = {
-    "./context" (module) {
-        module.exports = require("./context.js");
-    },
     "./edge" (module) {
         module.exports = require("./edge.js");
     },
@@ -17,6 +14,9 @@ var __webpack_modules__ = {
     },
     "@effect/opentelemetry" (module) {
         module.exports = require("@effect/opentelemetry");
+    },
+    "@modern-js/bff-effect/context" (module) {
+        module.exports = require("@modern-js/bff-effect/context");
     }
 };
 var __webpack_module_cache__ = {};
@@ -67,7 +67,7 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     var _effect_opentelemetry__rspack_import_0 = __webpack_require__("@effect/opentelemetry");
-    var _context__rspack_import_1 = __webpack_require__("./context");
+    var _modern_js_bff_effect_context__rspack_import_1 = __webpack_require__("@modern-js/bff-effect/context");
     var _edge__rspack_import_2 = __webpack_require__("./edge");
     var _endpoint_contracts__rspack_import_3 = __webpack_require__("./endpoint-contracts");
     var __rspack_reexport = {};
@@ -104,12 +104,12 @@ var __webpack_exports__ = {};
         OpenTelemetry: ()=>_effect_opentelemetry__rspack_import_0,
         createEffectBffEdgeHandler: ()=>_edge__rspack_import_2.createEffectBffEdgeHandler,
         createEffectBffTestHandler: ()=>_edge__rspack_import_2.createEffectBffTestHandler,
-        createEffectOperationContext: ()=>_context__rspack_import_1.createEffectOperationContext,
+        createEffectOperationContext: ()=>_modern_js_bff_effect_context__rspack_import_1.createEffectOperationContext,
         dispatchEffectBffRequest: ()=>_edge__rspack_import_2.dispatchEffectBffRequest,
         resolveEffectBffModuleHandler: ()=>_module__rspack_import_5.resolveEffectBffModuleHandler,
-        runWithEffectContext: ()=>_context__rspack_import_1.runWithEffectContext,
-        useEffectContext: ()=>_context__rspack_import_1.useEffectContext,
-        useOperationContext: ()=>_context__rspack_import_1.useOperationContext
+        runWithEffectContext: ()=>_modern_js_bff_effect_context__rspack_import_1.runWithEffectContext,
+        useEffectContext: ()=>_modern_js_bff_effect_context__rspack_import_1.useEffectContext,
+        useOperationContext: ()=>_modern_js_bff_effect_context__rspack_import_1.useOperationContext
     });
 })();
 exports.OpenTelemetry = __webpack_exports__.OpenTelemetry;

package/dist/cjs/effect/module.js

@@ -30,7 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     resolveEffectBffModuleHandler: ()=>resolveEffectBffModuleHandler
 });
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const http_api_namespaceObject = require("effect/http-api");
 const external_entry_shape_js_namespaceObject = require("./entry-shape.js");
 const external_handler_js_namespaceObject = require("./handler.js");
 function isRequestHandler(value) {
@@ -66,7 +66,7 @@ function classifyEffectBffRuntimeEntryShape(module) {
     return (0, external_entry_shape_js_namespaceObject.classifyEffectBffEntryModule)(module, {
         isRequestHandler,
         isValidatorAwareHandlerFactory: external_entry_shape_js_namespaceObject.isValidatorAwareHandlerFactory,
-        isHttpApi: httpapi_namespaceObject.HttpApi.isHttpApi
+        isHttpApi: http_api_namespaceObject.HttpApi.isHttpApi
     });
 }
 function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
@@ -74,6 +74,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/cjs/effect/operation-context.js

@@ -28,11 +28,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createEffectOperationContext: ()=>createEffectOperationContext,
-    kEffectContextStorage: ()=>kEffectContextStorage
+    createEffectOperationContext: ()=>createEffectOperationContext
 });
 const request_context_namespaceObject = require("@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;
@@ -87,7 +85,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
@@ -106,10 +104,8 @@ const createEffectOperationContext = ({ request, path, method })=>{
     };
 };
 exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
-exports.kEffectContextStorage = __webpack_exports__.kEffectContextStorage;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createEffectOperationContext",
-    "kEffectContextStorage"
+    "createEffectOperationContext"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/effect/rpcSerialization.js

@@ -30,7 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     getRpcSerializationLayer: ()=>getRpcSerializationLayer
 });
-const rpc_namespaceObject = require("effect/unstable/rpc");
+const rpc_namespaceObject = require("effect/rpc");
 function getRpcSerializationLayer(serialization) {
     switch(serialization){
         case 'ndjson':
@@ -39,8 +39,6 @@ function getRpcSerializationLayer(serialization) {
             return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
         case 'ndJsonRpc':
             return rpc_namespaceObject.RpcSerialization.layerNdJsonRpc();
-        case 'msgPack':
-            return rpc_namespaceObject.RpcSerialization.layerMsgPack;
         default:
             return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
     }

package/dist/cjs/effect-client/cross-project.js

@@ -33,13 +33,13 @@ __webpack_require__.d(__webpack_exports__, {
 const bff_policy_namespaceObject = require("@modern-js/server-runtime-extensions/bff-policy");
 const Effect_namespaceObject = require("effect/Effect");
 const Schema_namespaceObject = require("effect/Schema");
-const http_namespaceObject = require("effect/unstable/http");
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const http_namespaceObject = require("effect/http");
+const http_api_namespaceObject = require("effect/http-api");
 const encodeJson = Schema_namespaceObject.encodeSync(Schema_namespaceObject.fromJsonString(Schema_namespaceObject.Unknown));
 function withCrossProjectPolicy(api, options, client) {
     const contracts = {};
     const prefix = options.prefix.replace(/\/$/, '');
-    httpapi_namespaceObject.HttpApi.reflect(api, {
+    http_api_namespaceObject.HttpApi.reflect(api, {
         onGroup: ()=>{},
         onEndpoint: ({ endpoint })=>{
             const routePath = `${prefix}${'/' === endpoint.path ? '' : endpoint.path}` || '/';
@@ -62,14 +62,11 @@ function withCrossProjectPolicy(api, options, client) {
         const contract = observed && contracts[`${observed.method}:${observed.routePath}`];
         if (void 0 === contract) return Effect_namespaceObject.die(new Error('[BFF][Effect] Request has no matching shared operation contract.'));
         return Effect_namespaceObject.gen(function*() {
-            const input = encodeJson({
-                httpMethod: contract.method,
-                name: contract.name,
-                requestId: options.requestId,
-                routePath: contract.routePath
-            });
-            const digest = yield* Effect_namespaceObject.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* Effect_namespaceObject.promise(()=>(0, bff_policy_namespaceObject.digestOperationContract)({
+                    httpMethod: contract.method,
+                    name: contract.name,
+                    routePath: contract.routePath
+                }, options.requestId));
             return request.pipe(http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_ENVELOPE_HEADER, encodeJson({
                 requestId: options.requestId
             })), http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_OPERATION_CONTEXT_HEADER, contract.operationId), http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_OPERATION_CONTEXT_DETAIL_HEADER, encodeJson({

package/dist/cjs/effect-client/index.js

@@ -30,11 +30,11 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Effect: ()=>Effect_namespaceObject,
     EffectRpcClientError: ()=>EffectRpcClientError,
-    HttpApi: ()=>httpapi_namespaceObject.HttpApi,
-    HttpApiClient: ()=>httpapi_namespaceObject.HttpApiClient,
-    HttpApiEndpoint: ()=>httpapi_namespaceObject.HttpApiEndpoint,
-    HttpApiGroup: ()=>httpapi_namespaceObject.HttpApiGroup,
-    HttpApiSchema: ()=>httpapi_namespaceObject.HttpApiSchema,
+    HttpApi: ()=>http_api_namespaceObject.HttpApi,
+    HttpApiClient: ()=>http_api_namespaceObject.HttpApiClient,
+    HttpApiEndpoint: ()=>http_api_namespaceObject.HttpApiEndpoint,
+    HttpApiGroup: ()=>http_api_namespaceObject.HttpApiGroup,
+    HttpApiSchema: ()=>http_api_namespaceObject.HttpApiSchema,
     HttpClientError: ()=>HttpClientError_namespaceObject,
     Layer: ()=>Layer_namespaceObject,
     Rpc: ()=>rpc_namespaceObject.Rpc,
@@ -54,16 +54,16 @@ const request_context_namespaceObject = require("@modern-js/runtime-extensions/r
 const Data_namespaceObject = require("effect/Data");
 const Effect_namespaceObject = require("effect/Effect");
 const Exit_namespaceObject = require("effect/Exit");
+const http_namespaceObject = require("effect/http");
+const http_api_namespaceObject = require("effect/http-api");
 const Layer_namespaceObject = require("effect/Layer");
 const ManagedRuntime_namespaceObject = require("effect/ManagedRuntime");
+const rpc_namespaceObject = require("effect/rpc");
 const Scope_namespaceObject = require("effect/Scope");
-const http_namespaceObject = require("effect/unstable/http");
-const httpapi_namespaceObject = require("effect/unstable/httpapi");
-const rpc_namespaceObject = require("effect/unstable/rpc");
 const rpcSerialization_js_namespaceObject = require("../effect/rpcSerialization.js");
 const external_cross_project_js_namespaceObject = require("./cross-project.js");
+const HttpClientError_namespaceObject = require("effect/http/HttpClientError");
 const Schema_namespaceObject = require("effect/Schema");
-const HttpClientError_namespaceObject = require("effect/unstable/http/HttpClientError");
 class EffectRpcClientError extends Data_namespaceObject.TaggedError('EffectRpcClientError') {
 }
 function isRecord(value) {
@@ -102,7 +102,7 @@ function makeEffectHttpApiClient(api, options) {
         const policyClient = options?.crossProject !== void 0 ? (0, external_cross_project_js_namespaceObject.withCrossProjectPolicy)(api, options.crossProject, contextClient) : contextClient;
         return 'function' == typeof options?.transformClient ? options.transformClient(policyClient) : policyClient;
     };
-    return httpapi_namespaceObject.HttpApiClient.make(api, {
+    return http_api_namespaceObject.HttpApiClient.make(api, {
         baseUrl: options?.baseUrl,
         transformClient,
         transformResponse: options?.transformResponse

package/dist/cjs/microvertical-api.js

@@ -66,7 +66,7 @@ const MicroVerticalOperationSourceSchema = external_effect_namespaceObject.Schem
     'client',
     'server',
     'generated-client',
-    'effect-adapter',
+    'effect-server',
     'data-platform',
     'unknown'
 ]);

package/dist/esm/assembly.mjs

@@ -1,4 +1,4 @@
-import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { HttpApiBuilder } from "effect/http-api";
 import { defineEffectBff } from "./effect/handler/definition.mjs";
 import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
 const assembleEffectBffRuntime = ({ api, handlers, transport })=>{

package/dist/esm/data-platform/batch/options.mjs

@@ -0,0 +1,10 @@
+function normalizeBatchLimits(options = {}) {
+    return {
+        maxBatchSize: Math.max(1, options.maxBatchSize ?? 16),
+        maxBatchBytes: Math.max(1024, options.maxBatchBytes ?? 65536),
+        allowedMethods: new Set((void 0 !== options.allowedMethods && options.allowedMethods.length > 0 ? options.allowedMethods : [
+            'GET'
+        ]).map((method)=>method.toUpperCase()))
+    };
+}
+export { normalizeBatchLimits };

package/dist/esm/data-platform/batch/queue.mjs

@@ -1,5 +1,6 @@
 import { stableStringify } from "../codec.mjs";
 import { DEFAULT_DATA_BATCH_HEADER } from "../types.mjs";
+import { normalizeBatchLimits } from "./options.mjs";
 import { decodeBatchBody, isNullBodyStatus } from "./protocol.mjs";
 import { createBatchId, measureTextBytes, normalizeMethod, shouldBatchRequest, toHeaderRecord, toRequestBody } from "./request.mjs";
 import { isBatchResponsePayload, parseResponseLikeCreateRequest } from "./response.mjs";
@@ -78,7 +79,6 @@ class BatchBucketRegistry {
         if (existing) return existing;
         const next = {
             items: [],
-            bytes: 0,
             batchId: createBatchId(),
             sentAt: Date.now(),
             timer: null,
@@ -97,12 +97,8 @@ class BatchBucketRegistry {
 }
 function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
     const flushIntervalMs = Math.max(0, options.flushIntervalMs ?? 8);
-    const maxBatchSize = Math.max(1, options.maxBatchSize ?? 16);
-    const maxBatchBytes = Math.max(1024, options.maxBatchBytes ?? 65536);
+    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();
     const pendingByKey = new Map();
@@ -135,7 +131,6 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const index = bucket.items.indexOf(request);
         if (-1 === index) return;
         bucket.items.splice(index, 1);
-        bucket.bytes = measurePayload(bucket, bucket.items);
         if (0 === bucket.items.length && bucket.timer) {
             clearTimeout(bucket.timer);
             bucket.timer = null;
@@ -177,7 +172,11 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         if (!SAFE_REPLAY_METHODS.has(request.item.method)) throw new Error(`Batch result is unknown for ${request.item.method}; automatic replay is disabled (${reason}).`);
         return runSingle(request);
     };
-    const settleAmbiguousBatchRequests = (items, reason)=>settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+    const finishFlush = (bucketKey, bucket)=>{
+        bucket.flushing = false;
+        if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
+        buckets.releaseIfIdle(bucketKey, bucket);
+    };
     const flushBucket = async (bucketKey)=>{
         const bucket = buckets.get(bucketKey);
         if (!bucket || bucket.flushing) return;
@@ -194,7 +193,6 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             sentAt: bucket.sentAt
         };
         bucket.items = [];
-        bucket.bytes = 0;
         rotatePayloadIdentity(bucket);
         const firstItem = items[0];
         if (!firstItem) {
@@ -210,14 +208,25 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                 size: items.length,
                 reason: disabledEndpoints.has(endpoint) ? 'batch-disabled' : void 0
             });
-            await settleRequests(items, runSingle);
-            bucket.flushing = false;
-            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
-            buckets.releaseIfIdle(bucketKey, bucket);
+            try {
+                await settleRequests(items, runSingle);
+            } finally{
+                finishFlush(bucketKey, bucket);
+            }
             return;
         }
         const payload = createPayload(payloadIdentity, items);
         const batchId = payload.batchId;
+        const settleAmbiguousBatchRequests = (reason)=>{
+            emitDataBatchTransportEvent(onEvent, {
+                type: 'fallback',
+                endpoint,
+                batchId,
+                size: items.length,
+                reason
+            });
+            return settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+        };
         emitDataBatchTransportEvent(onEvent, {
             type: 'flush',
             endpoint,
@@ -268,42 +277,13 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                         batchId,
                         reason: `batch-endpoint-unavailable-${String(response.status)}`
                     });
-                } else emitDataBatchTransportEvent(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: `batch-response-${String(response.status)}`
-                });
-                await settleAmbiguousBatchRequests(items, `batch-response-${String(response.status)}`);
-                bucket.flushing = false;
+                    await settleRequests(items, (request)=>runAfterAmbiguousBatch(request, `batch-response-${String(response.status)}`));
+                } else await settleAmbiguousBatchRequests(`batch-response-${String(response.status)}`);
                 return;
             }
             const result = await runWithSignal(controller.signal, async ()=>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;
-                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;
-                return;
-            }
+            if (!isBatchResponsePayload(result)) return void await settleAmbiguousBatchRequests('invalid-batch-response');
+            if (result.batchId !== batchId) return void await settleAmbiguousBatchRequests('mismatched-batch-id');
             const itemMap = new Map();
             for (const item of result.items)itemMap.set(item.id, item);
             await settleRequests(items, async (request)=>{
@@ -327,19 +307,10 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                 });
                 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 = void 0;
-            bucket.flushing = false;
-            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
-            buckets.releaseIfIdle(bucketKey, bucket);
+            finishFlush(bucketKey, bucket);
         }
     };
     const pendingReadPromises = new Map();
@@ -363,7 +334,20 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const sourceSignal = initDefinesSignal ? initSignal ?? void 0 : sourceRequest?.signal;
         const requestUrl = toAbsoluteUrl(input);
         const endpoint = normalizeBatchEndpoint(requestUrl, 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,
@@ -396,22 +380,11 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             batchEndpoint: request.endpoint,
             requestUrl: request.requestUrl
         })) return;
-        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
         });
     };
@@ -429,26 +402,19 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const itemId = `${Date.now().toString(36)}_${nextItemId.toString(36)}_${Math.random().toString(16).slice(2, 8)}`;
         nextItemId += 1;
         const itemHeaders = {
-            ...request.headers
+            ...request.itemHeaders
         };
-        delete itemHeaders.authorization;
-        delete itemHeaders.cookie;
         if (preparedBody.body && preparedBody.inferredContentType && !itemHeaders['content-type']) itemHeaders['content-type'] = preparedBody.inferredContentType;
         const item = {
             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,
             path: item.path,
@@ -542,13 +508,12 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             }
         }
         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) {
             flushBucket(bucketKey);
             return queued.promise;
         }