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

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

@@ -6,12 +6,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);
 }
@@ -109,4 +103,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/effect-client/cross-project.mjs

@@ -1,4 +1,4 @@
-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";
@@ -30,14 +30,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/data-platform/batch/options.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+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-node/data-platform/batch/queue.mjs

@@ -1,6 +1,7 @@
 import "node:module";
 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";
@@ -79,7 +80,6 @@ class BatchBucketRegistry {
         if (existing) return existing;
         const next = {
             items: [],
-            bytes: 0,
             batchId: createBatchId(),
             sentAt: Date.now(),
             timer: null,
@@ -98,12 +98,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();
@@ -136,7 +132,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;
@@ -178,7 +173,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;
@@ -195,7 +194,6 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             sentAt: bucket.sentAt
         };
         bucket.items = [];
-        bucket.bytes = 0;
         rotatePayloadIdentity(bucket);
         const firstItem = items[0];
         if (!firstItem) {
@@ -211,14 +209,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,
@@ -269,42 +278,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)=>{
@@ -328,19 +308,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();
@@ -364,7 +335,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,
@@ -397,22 +381,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
         });
     };
@@ -430,26 +403,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,
@@ -543,13 +509,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;
         }

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-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/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/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/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "ultramodern.js"
   ],
-  "version": "3.9.0-ultramodern.11",
+  "version": "3.9.0-ultramodern.12",
   "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.12",
+    "@modern-js/create-request": "npm:@bleedingdev/modern-js-create-request@3.9.0-ultramodern.12",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.12",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.12",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/api-logs": "0.222.0",
     "@opentelemetry/resources": "2.11.0",

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()),
+    ),
+  };
+}