@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/cjs/runtime/data-platform/index.js

@@ -28,640 +28,37 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    DATA_BATCH_TRANSPORT_OTEL_EVENT: ()=>DATA_BATCH_TRANSPORT_OTEL_EVENT,
-    DEFAULT_DATA_BATCH_ENDPOINT: ()=>DEFAULT_DATA_BATCH_ENDPOINT,
-    DEFAULT_DATA_BATCH_HEADER: ()=>DEFAULT_DATA_BATCH_HEADER,
-    DEFAULT_DATA_ENVELOPE_HEADER: ()=>DEFAULT_DATA_ENVELOPE_HEADER,
-    buildQueryKey: ()=>buildQueryKey,
-    buildScopeKey: ()=>buildScopeKey,
-    createDataBatchTransport: ()=>createDataBatchTransport,
-    createDataBatchTransportTelemetryAttributes: ()=>createDataBatchTransportTelemetryAttributes,
-    createHydrationEnvelope: ()=>createHydrationEnvelope,
-    createInvalidationEvent: ()=>createInvalidationEvent,
-    createOperationId: ()=>createOperationId,
-    createRequestEnvelope: ()=>createRequestEnvelope,
-    decodeRequestEnvelopeHeader: ()=>decodeRequestEnvelopeHeader,
-    deriveChildTraceContext: ()=>deriveChildTraceContext,
-    emitDataBatchTransportEvent: ()=>emitDataBatchTransportEvent,
-    encodeRequestEnvelopeHeader: ()=>encodeRequestEnvelopeHeader,
-    formatTraceparentHeader: ()=>formatTraceparentHeader,
-    normalizeOrigin: ()=>normalizeOrigin,
-    parseTraceparentHeader: ()=>parseTraceparentHeader,
-    shouldApplyInvalidation: ()=>shouldApplyInvalidation,
-    stableStringify: ()=>stableStringify,
-    validateHydrationEnvelope: ()=>validateHydrationEnvelope,
-    validateRequestEnvelope: ()=>validateRequestEnvelope,
-    validateSelectionPlan: ()=>validateSelectionPlan
+    DATA_BATCH_TRANSPORT_OTEL_EVENT: ()=>external_batch_transport_js_namespaceObject.DATA_BATCH_TRANSPORT_OTEL_EVENT,
+    DEFAULT_DATA_BATCH_ENDPOINT: ()=>external_types_js_namespaceObject.DEFAULT_DATA_BATCH_ENDPOINT,
+    DEFAULT_DATA_BATCH_HEADER: ()=>external_types_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER,
+    DEFAULT_DATA_ENVELOPE_HEADER: ()=>external_types_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER,
+    buildQueryKey: ()=>external_codec_js_namespaceObject.buildQueryKey,
+    buildScopeKey: ()=>external_codec_js_namespaceObject.buildScopeKey,
+    createDataBatchTransport: ()=>external_batch_transport_js_namespaceObject.createDataBatchTransport,
+    createDataBatchTransportTelemetryAttributes: ()=>external_batch_transport_js_namespaceObject.createDataBatchTransportTelemetryAttributes,
+    createHydrationEnvelope: ()=>external_validation_js_namespaceObject.createHydrationEnvelope,
+    createInvalidationEvent: ()=>external_invalidation_js_namespaceObject.createInvalidationEvent,
+    createOperationId: ()=>external_codec_js_namespaceObject.createOperationId,
+    createRequestEnvelope: ()=>external_validation_js_namespaceObject.createRequestEnvelope,
+    decodeRequestEnvelopeHeader: ()=>external_codec_js_namespaceObject.decodeRequestEnvelopeHeader,
+    deriveChildTraceContext: ()=>external_trace_js_namespaceObject.deriveChildTraceContext,
+    emitDataBatchTransportEvent: ()=>external_batch_transport_js_namespaceObject.emitDataBatchTransportEvent,
+    encodeRequestEnvelopeHeader: ()=>external_codec_js_namespaceObject.encodeRequestEnvelopeHeader,
+    formatTraceparentHeader: ()=>external_trace_js_namespaceObject.formatTraceparentHeader,
+    normalizeOrigin: ()=>external_codec_js_namespaceObject.normalizeOrigin,
+    parseTraceparentHeader: ()=>external_trace_js_namespaceObject.parseTraceparentHeader,
+    shouldApplyInvalidation: ()=>external_invalidation_js_namespaceObject.shouldApplyInvalidation,
+    stableStringify: ()=>external_codec_js_namespaceObject.stableStringify,
+    validateHydrationEnvelope: ()=>external_validation_js_namespaceObject.validateHydrationEnvelope,
+    validateRequestEnvelope: ()=>external_validation_js_namespaceObject.validateRequestEnvelope,
+    validateSelectionPlan: ()=>external_validation_js_namespaceObject.validateSelectionPlan
 });
-const create_request_namespaceObject = require("@modern-js/create-request");
-const api_namespaceObject = require("@opentelemetry/api");
-const DATA_BATCH_TRANSPORT_OTEL_EVENT = 'modernjs.data.batch';
-function createDataBatchTransportTelemetryAttributes(event) {
-    return {
-        'modernjs.data.batch.type': event.type,
-        'modernjs.data.batch.endpoint': event.endpoint,
-        'modernjs.data.batch.degraded': 'fallback' === event.type || 'disable' === event.type,
-        ...event.batchId ? {
-            'modernjs.data.batch.id': event.batchId
-        } : {},
-        ...'number' == typeof event.size ? {
-            'modernjs.data.batch.size': event.size
-        } : {},
-        ...event.reason ? {
-            'modernjs.data.batch.reason': event.reason
-        } : {}
-    };
-}
-function emitDataBatchTransportEvent(onEvent, event) {
-    onEvent?.(event);
-    api_namespaceObject.trace.getActiveSpan()?.addEvent(DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes(event));
-}
-const DEFAULT_DATA_ENVELOPE_HEADER = 'x-modernjs-data-envelope';
-const DEFAULT_DATA_BATCH_ENDPOINT = '/_data/batch';
-const DEFAULT_DATA_BATCH_HEADER = 'x-modernjs-data-batch';
-function isPlainObject(value) {
-    if ('object' != typeof value || null === value || Array.isArray(value)) return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || null === proto;
-}
-function canonicalize(value) {
-    if (Array.isArray(value)) return value.map((item)=>canonicalize(item));
-    if (isPlainObject(value)) return Object.keys(value).sort().reduce((acc, key)=>{
-        acc[key] = canonicalize(value[key]);
-        return acc;
-    }, {});
-    return value;
-}
-function stableStringify(value) {
-    return JSON.stringify(canonicalize(value));
-}
-function encodeRequestEnvelopeHeader(envelope) {
-    return encodeURIComponent(stableStringify(envelope));
-}
-function isRequestEnvelopeShape(value) {
-    if (!isPlainObject(value)) return false;
-    return 1 === value.protocolVersion && 'string' == typeof value.operationId && 'string' == typeof value.appNamespace && 'string' == typeof value.origin && 'string' == typeof value.scopeKey && 'string' == typeof value.inputHash && 'number' == typeof value.timestamp;
-}
-function decodeRequestEnvelopeHeader(value) {
-    try {
-        const decoded = decodeURIComponent(value);
-        const parsed = JSON.parse(decoded);
-        if (!isRequestEnvelopeShape(parsed)) return null;
-        return parsed;
-    } catch  {
-        return null;
-    }
-}
-function hashString(value) {
-    let hash = 0x811c9dc5;
-    for(let index = 0; index < value.length; index++){
-        hash ^= value.charCodeAt(index);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(16).padStart(8, '0');
-}
-function sanitizeSegment(segment) {
-    const normalized = segment.trim().replace(/[^a-zA-Z0-9_-]+/g, '_');
-    return normalized.length > 0 ? normalized : 'unknown';
-}
-function normalizeOrigin(origin) {
-    const normalized = origin.trim();
-    try {
-        const url = new URL(normalized);
-        return `${url.protocol}//${url.host}`.toLowerCase();
-    } catch  {
-        return normalized.toLowerCase();
-    }
-}
-function normalizeOperationDescriptor(input) {
-    return {
-        appNamespace: sanitizeSegment(input.appNamespace),
-        apiId: sanitizeSegment(input.apiId),
-        group: sanitizeSegment(input.group),
-        endpoint: sanitizeSegment(input.endpoint),
-        schemaHash: input.schemaHash || null,
-        version: input.version ?? 1
-    };
-}
-function createOperationId(input) {
-    const descriptor = normalizeOperationDescriptor(input);
-    const readable = `${descriptor.appNamespace}.${descriptor.apiId}.${descriptor.group}.${descriptor.endpoint}.v${String(descriptor.version)}`;
-    return `${readable}:${hashString(stableStringify(descriptor))}`;
-}
-function buildScopeKey(scope) {
-    const canonical = {
-        appNamespace: sanitizeSegment(scope.appNamespace),
-        origin: normalizeOrigin(scope.origin),
-        tenantId: scope.tenantId ?? null,
-        userId: scope.userId ?? null,
-        sessionId: scope.sessionId ?? null
-    };
-    return `${canonical.appNamespace}:${hashString(stableStringify(canonical))}`;
-}
-function buildQueryKey(input) {
-    const canonical = {
-        operationId: input.operationId,
-        scopeKey: input.scopeKey,
-        requestMode: input.requestMode ?? 'cache-first',
-        requestInput: input.requestInput ?? null,
-        selectionPlan: input.selectionPlan ?? null
-    };
-    return `${input.operationId}:${hashString(stableStringify(canonical))}`;
-}
-function isAllZeroHex(value) {
-    return /^0+$/.test(value);
-}
-function isValidHex(value, length) {
-    return value.length === length && /^[0-9a-f]+$/.test(value);
-}
-function parseTraceparentHeader(header) {
-    return (0, create_request_namespaceObject.parseTraceparent)(header) ?? null;
-}
-function formatTraceparentHeader(trace) {
-    const traceId = trace.traceId.toLowerCase();
-    const spanId = trace.spanId.toLowerCase();
-    if (!isValidHex(traceId, 32) || !isValidHex(spanId, 16)) throw new Error('Invalid trace context: traceId/spanId format mismatch');
-    if (isAllZeroHex(traceId) || isAllZeroHex(spanId)) throw new Error('Invalid trace context: traceId/spanId cannot be zero');
-    const flags = trace.sampled ? '01' : '00';
-    return `00-${traceId}-${spanId}-${flags}`;
-}
-function deriveChildTraceContext(parent, childSpanId) {
-    const normalizedSpanId = childSpanId.toLowerCase();
-    if (!isValidHex(normalizedSpanId, 16) || isAllZeroHex(normalizedSpanId)) throw new Error('Invalid child span id');
-    return {
-        traceId: parent.traceId.toLowerCase(),
-        spanId: normalizedSpanId,
-        sampled: parent.sampled,
-        parentSpanId: parent.spanId.toLowerCase()
-    };
-}
-function validateSelectionPlan(plan, options = {}) {
-    const maxDepthLimit = options.maxDepth ?? 8;
-    const maxFieldsLimit = options.maxFields ?? 256;
-    const allowedLeafPaths = options.allowedLeafPaths ? new Set(options.allowedLeafPaths) : null;
-    const errors = [];
-    let maxDepth = 0;
-    let fieldCount = 0;
-    const walk = (node, path)=>{
-        if (!isPlainObject(node)) return void errors.push(`Selection node at "${path.join('.') || '<root>'}" must be an object`);
-        const keys = Object.keys(node);
-        if (0 === keys.length) return void errors.push(`Selection node at "${path.join('.') || '<root>'}" cannot be empty`);
-        for (const key of keys){
-            fieldCount += 1;
-            if (fieldCount > maxFieldsLimit) return void errors.push(`Selection has too many fields: ${String(fieldCount)} > ${String(maxFieldsLimit)}`);
-            const nextPath = [
-                ...path,
-                key
-            ];
-            const depth = nextPath.length;
-            if (depth > maxDepth) maxDepth = depth;
-            if (depth > maxDepthLimit) return void errors.push(`Selection exceeds maxDepth at "${nextPath.join('.')}" (${String(depth)} > ${String(maxDepthLimit)})`);
-            const value = node[key];
-            if (true === value) {
-                if (allowedLeafPaths && !allowedLeafPaths.has(nextPath.join('.'))) errors.push(`Unknown selected field "${nextPath.join('.')}"`);
-                continue;
-            }
-            if (!isPlainObject(value)) {
-                errors.push(`Invalid selection value at "${nextPath.join('.')}"; expected true or nested object`);
-                continue;
-            }
-            walk(value, nextPath);
-        }
-    };
-    walk(plan, []);
-    return {
-        ok: 0 === errors.length,
-        errors,
-        stats: {
-            maxDepth,
-            fieldCount
-        }
-    };
-}
-function createRequestEnvelope(input) {
-    if (input.requireTraceContext && !input.traceContext) throw new Error('Trace context is required for this request envelope');
-    const traceparent = input.traceContext ? formatTraceparentHeader(input.traceContext) : void 0;
-    const envelope = {
-        protocolVersion: input.protocolVersion ?? 1,
-        operationId: createOperationId(input.operation),
-        appNamespace: sanitizeSegment(input.scope.appNamespace),
-        origin: normalizeOrigin(input.scope.origin),
-        requestMode: input.requestMode ?? 'cache-first',
-        mutationMode: input.mutationMode,
-        scopeKey: buildScopeKey(input.scope),
-        input: input.requestInput,
-        inputHash: hashString(stableStringify(input.requestInput ?? null)),
-        selectionPlan: input.selectionPlan,
-        selectionHash: input.selectionPlan ? hashString(stableStringify(input.selectionPlan)) : void 0,
-        traceparent,
-        timestamp: input.timestamp ?? Date.now()
-    };
-    return envelope;
-}
-function validateRequestEnvelope(envelope, options = {}) {
-    const errors = [];
-    if (void 0 !== options.expectedProtocolVersion && envelope.protocolVersion !== options.expectedProtocolVersion) errors.push(`Protocol mismatch: expected ${String(options.expectedProtocolVersion)} but received ${String(envelope.protocolVersion)}`);
-    if (options.expectedNamespace && envelope.appNamespace !== options.expectedNamespace) errors.push(`Namespace mismatch: expected ${options.expectedNamespace} but received ${envelope.appNamespace}`);
-    if (options.expectedOrigin) {
-        const expectedOrigin = normalizeOrigin(options.expectedOrigin);
-        if (envelope.origin !== expectedOrigin) errors.push(`Origin mismatch: expected ${expectedOrigin} but received ${envelope.origin}`);
-    }
-    if (!envelope.operationId) errors.push('Missing operationId');
-    if (!envelope.scopeKey) errors.push('Missing scopeKey');
-    if (options.requireTraceContext && !envelope.traceparent) errors.push('Missing trace context');
-    if (envelope.traceparent && !parseTraceparentHeader(envelope.traceparent)) errors.push('Invalid traceparent header');
-    const computedInputHash = hashString(stableStringify(envelope.input ?? null));
-    if (computedInputHash !== envelope.inputHash) errors.push('Input hash mismatch');
-    if (envelope.selectionPlan) {
-        const computedSelectionHash = hashString(stableStringify(envelope.selectionPlan));
-        if (computedSelectionHash !== envelope.selectionHash) errors.push('Selection hash mismatch');
-    }
-    return {
-        ok: 0 === errors.length,
-        errors
-    };
-}
-function createHydrationEnvelope(input) {
-    const envelopeWithoutChecksum = {
-        protocolVersion: input.protocolVersion ?? 1,
-        runtimeVersion: input.runtimeVersion,
-        appNamespace: sanitizeSegment(input.scope.appNamespace),
-        origin: normalizeOrigin(input.scope.origin),
-        createdAt: input.createdAt ?? Date.now(),
-        payload: input.payload
-    };
-    const checksum = hashString(stableStringify(envelopeWithoutChecksum));
-    return {
-        ...envelopeWithoutChecksum,
-        checksum
-    };
-}
-function validateHydrationEnvelope(envelope, options = {}) {
-    const errors = [];
-    if (void 0 !== options.expectedProtocolVersion && envelope.protocolVersion !== options.expectedProtocolVersion) errors.push(`Protocol mismatch: expected ${String(options.expectedProtocolVersion)} but received ${String(envelope.protocolVersion)}`);
-    if (options.expectedNamespace && envelope.appNamespace !== options.expectedNamespace) errors.push(`Namespace mismatch: expected ${options.expectedNamespace} but received ${envelope.appNamespace}`);
-    if (options.expectedOrigin) {
-        const expectedOrigin = normalizeOrigin(options.expectedOrigin);
-        if (envelope.origin !== expectedOrigin) errors.push(`Origin mismatch: expected ${expectedOrigin} but received ${envelope.origin}`);
-    }
-    if (options.expectedRuntimeVersion && envelope.runtimeVersion !== options.expectedRuntimeVersion) errors.push(`Runtime version mismatch: expected ${options.expectedRuntimeVersion} but received ${envelope.runtimeVersion}`);
-    const checksumBase = {
-        protocolVersion: envelope.protocolVersion,
-        runtimeVersion: envelope.runtimeVersion,
-        appNamespace: envelope.appNamespace,
-        origin: envelope.origin,
-        createdAt: envelope.createdAt,
-        payload: envelope.payload
-    };
-    const checksum = hashString(stableStringify(checksumBase));
-    if (checksum !== envelope.checksum) errors.push('Hydration checksum mismatch');
-    return {
-        ok: 0 === errors.length,
-        errors
-    };
-}
-function createInvalidationEvent(input) {
-    return {
-        sourceNamespace: sanitizeSegment(input.sourceOperation.appNamespace),
-        sourceOperationId: createOperationId(input.sourceOperation),
-        scopeKey: buildScopeKey(input.sourceScope),
-        targetNamespaces: input.targetNamespaces?.map((namespace)=>sanitizeSegment(namespace)),
-        targetOperationIds: input.targetOperations?.map((operation)=>createOperationId(operation))
-    };
-}
-function shouldApplyInvalidation(event, subscriber) {
-    if (subscriber.scopeKey && subscriber.scopeKey !== event.scopeKey) return false;
-    const sameNamespace = subscriber.namespace === event.sourceNamespace;
-    const allowedCrossNamespace = true === subscriber.acceptCrossNamespace && event.targetNamespaces?.includes(subscriber.namespace) === true;
-    if (!sameNamespace && !allowedCrossNamespace) return false;
-    if (!subscriber.operationIds || 0 === subscriber.operationIds.length) return true;
-    if (!event.targetOperationIds || 0 === event.targetOperationIds.length) return true;
-    return subscriber.operationIds.some((operationId)=>event.targetOperationIds?.includes(operationId));
-}
-function resolveRuntimeOrigin() {
-    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
-    if ("u" > typeof globalThis && globalThis.location && 'string' == typeof globalThis.location?.origin) return globalThis.location.origin;
-    return 'http://localhost';
-}
-function toAbsoluteUrl(input) {
-    if (input instanceof URL) return input;
-    if ("u" > typeof Request && input instanceof Request) return new URL(input.url);
-    const value = String(input);
-    try {
-        return new URL(value);
-    } catch  {
-        return new URL(value, resolveRuntimeOrigin());
-    }
-}
-function normalizeBatchEndpoint(requestUrl, endpoint) {
-    const value = endpoint || DEFAULT_DATA_BATCH_ENDPOINT;
-    try {
-        return new URL(value);
-    } catch  {
-        return new URL(value, requestUrl.origin);
-    }
-}
-function toHeaderRecord(headers) {
-    if (!headers) return {};
-    if (headers instanceof Headers) {
-        const next = {};
-        headers.forEach((value, key)=>{
-            next[key.toLowerCase()] = value;
-        });
-        return next;
-    }
-    if (Array.isArray(headers)) return headers.reduce((acc, [key, value])=>{
-        acc[String(key).toLowerCase()] = String(value);
-        return acc;
-    }, {});
-    return Object.entries(headers).reduce((acc, [key, value])=>{
-        if (void 0 === value) return acc;
-        acc[String(key).toLowerCase()] = Array.isArray(value) ? value.join(', ') : String(value);
-        return acc;
-    }, {});
-}
-function isBatchResponseItem(value) {
-    return isPlainObject(value) && 'string' == typeof value.id && 'number' == typeof value.status;
-}
-function isBatchResponsePayload(value) {
-    return isPlainObject(value) && 1 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.receivedAt && Array.isArray(value.items) && value.items.every((item)=>isBatchResponseItem(item));
-}
-function measureTextBytes(value) {
-    if ("u" > typeof TextEncoder) return new TextEncoder().encode(value).length;
-    if ("u" > typeof Buffer) return Buffer.byteLength(value);
-    return value.length;
-}
-function createBatchId() {
-    const now = Date.now().toString(36);
-    const random = Math.random().toString(16).slice(2, 10);
-    return `batch_${now}_${random}`;
-}
-function normalizeMethod(method) {
-    return (method || 'GET').toUpperCase();
-}
-function toRequestBody(initBody) {
-    if ('string' == typeof initBody) return initBody;
-    if ("u" > typeof URLSearchParams && initBody instanceof URLSearchParams) return initBody.toString();
-}
-function shouldBatchRequest(input) {
-    if (input.requestUrl.href === input.batchEndpoint) return false;
-    if ('off' === input.headers[DEFAULT_DATA_BATCH_HEADER]) return false;
-    if (!input.allowedMethods.has(input.method)) return false;
-    if (void 0 !== input.body) return false;
-    return true;
-}
-async function parseResponseLikeCreateRequest(response) {
-    const contentType = response.headers.get('content-type') || '';
-    if (!response.ok) {
-        let data = null;
-        data = contentType.includes('application/json') ? await response.json() : await response.text();
-        response.data = data;
-        throw response;
-    }
-    if (contentType.includes('application/json') || contentType.includes('text/json')) return response.json();
-    if (contentType.includes('text/html') || contentType.includes('text/plain')) return response.text();
-    if (contentType.includes('application/x-www-form-urlencoded') || contentType.includes('multipart/form-data')) return response.formData();
-    if (contentType.includes('application/octet-stream')) return response.arrayBuffer();
-    if (contentType.includes('image/png')) return response;
-    return response.text();
-}
-function ensureBucket(buckets, endpoint) {
-    const existing = buckets.get(endpoint);
-    if (existing) return existing;
-    const next = {
-        items: [],
-        bytes: 0,
-        timer: null,
-        flushing: false
-    };
-    buckets.set(endpoint, next);
-    return next;
-}
-function createDataBatchTransport(options = {}) {
-    const fallbackFetch = 'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
-    const baseFetch = options.fetch || fallbackFetch;
-    if (!baseFetch) throw new Error('createDataBatchTransport requires a fetch implementation');
-    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 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 = new Map();
-    const pendingByKey = new Map();
-    const disabledEndpoints = new Set();
-    const runSingle = async (request)=>{
-        const response = await baseFetch(request.requestUrl, request.requestInit);
-        return parseResponseLikeCreateRequest(response);
-    };
-    const settleRequests = async (items, runner)=>{
-        await Promise.all(items.map(async (item)=>{
-            try {
-                const value = await runner(item);
-                item.resolve(value);
-            } catch (error) {
-                item.reject(error);
-            } finally{
-                pendingByKey.delete(item.key);
-            }
-        }));
-    };
-    const flushBucket = async (endpoint)=>{
-        const bucket = buckets.get(endpoint);
-        if (!bucket || bucket.flushing) return;
-        if (bucket.timer) {
-            clearTimeout(bucket.timer);
-            bucket.timer = null;
-        }
-        if (0 === bucket.items.length) return;
-        bucket.flushing = true;
-        const items = bucket.items;
-        bucket.items = [];
-        bucket.bytes = 0;
-        if (1 === items.length || disabledEndpoints.has(endpoint)) {
-            emitDataBatchTransportEvent(onEvent, {
-                type: disabledEndpoints.has(endpoint) ? 'fallback' : 'flush',
-                endpoint,
-                size: items.length,
-                reason: disabledEndpoints.has(endpoint) ? 'batch-disabled' : void 0
-            });
-            await settleRequests(items, runSingle);
-            bucket.flushing = false;
-            return;
-        }
-        const batchId = createBatchId();
-        const payload = {
-            protocolVersion: 1,
-            batchId,
-            sentAt: Date.now(),
-            items: items.map((item)=>item.item)
-        };
-        emitDataBatchTransportEvent(onEvent, {
-            type: 'flush',
-            endpoint,
-            batchId,
-            size: items.length
-        });
-        const payloadJson = JSON.stringify(payload);
-        const traceparent = items.find((item)=>'string' == typeof item.item.headers?.traceparent)?.item.headers?.traceparent || void 0;
-        const requestInit = {
-            method: 'POST',
-            headers: {
-                accept: 'application/json, */*;q=0.8',
-                'content-type': 'application/json; charset=utf-8',
-                [DEFAULT_DATA_BATCH_HEADER]: '1',
-                ...traceparent ? {
-                    traceparent
-                } : {}
-            },
-            body: payloadJson
-        };
-        let timeoutHandle = null;
-        try {
-            const controller = requestTimeoutMs && requestTimeoutMs > 0 ? new AbortController() : void 0;
-            if (controller) {
-                requestInit.signal = controller.signal;
-                timeoutHandle = setTimeout(()=>{
-                    controller.abort();
-                    emitDataBatchTransportEvent(onEvent, {
-                        type: 'fallback',
-                        endpoint,
-                        batchId,
-                        size: items.length,
-                        reason: 'batch-timeout'
-                    });
-                }, requestTimeoutMs);
-            }
-            const response = await baseFetch(endpoint, requestInit);
-            if (!response.ok) {
-                if (404 === response.status || 405 === response.status) {
-                    disabledEndpoints.add(endpoint);
-                    emitDataBatchTransportEvent(onEvent, {
-                        type: 'disable',
-                        endpoint,
-                        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 settleRequests(items, runSingle);
-                bucket.flushing = false;
-                return;
-            }
-            const result = await response.json();
-            if (!isBatchResponsePayload(result)) {
-                emitDataBatchTransportEvent(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: 'invalid-batch-response'
-                });
-                await settleRequests(items, runSingle);
-                bucket.flushing = false;
-                return;
-            }
-            const itemMap = new Map();
-            for (const item of result.items)itemMap.set(item.id, item);
-            await settleRequests(items, async (request)=>{
-                const resultItem = itemMap.get(request.item.id);
-                if (!resultItem) return runSingle(request);
-                const reconstructedResponse = new Response(resultItem.body ?? '', {
-                    status: resultItem.status,
-                    headers: resultItem.headers
-                });
-                return parseResponseLikeCreateRequest(reconstructedResponse);
-            });
-        } catch (error) {
-            emitDataBatchTransportEvent(onEvent, {
-                type: 'fallback',
-                endpoint,
-                batchId,
-                size: items.length,
-                reason: 'batch-transport-error'
-            });
-            await settleRequests(items, runSingle);
-        } finally{
-            if (timeoutHandle) clearTimeout(timeoutHandle);
-            bucket.flushing = false;
-        }
-    };
-    return (input, init)=>{
-        const requestUrl = toAbsoluteUrl(input);
-        const batchEndpointUrl = normalizeBatchEndpoint(requestUrl, options.endpoint);
-        const endpoint = batchEndpointUrl.toString();
-        const method = normalizeMethod(init?.method);
-        const body = toRequestBody(init?.body ?? null);
-        const headers = toHeaderRecord(init?.headers);
-        const normalizedInit = {
-            ...init,
-            method,
-            headers,
-            body
-        };
-        if (disabledEndpoints.has(endpoint) || !shouldBatchRequest({
-            method,
-            body,
-            headers,
-            allowedMethods,
-            batchEndpoint: endpoint,
-            requestUrl
-        })) return baseFetch(requestUrl.toString(), normalizedInit).then(parseResponseLikeCreateRequest);
-        const item = {
-            id: `${Date.now().toString(36)}_${Math.random().toString(16).slice(2, 8)}`,
-            path: `${requestUrl.pathname}${requestUrl.search}`,
-            method,
-            headers,
-            ...body ? {
-                body
-            } : {}
-        };
-        const key = stableStringify({
-            endpoint,
-            path: item.path,
-            method: item.method,
-            headers: item.headers,
-            body: item.body ?? null
-        });
-        const existing = pendingByKey.get(key);
-        if (existing) return existing;
-        const size = measureTextBytes(stableStringify(item));
-        const promise = new Promise((resolve, reject)=>{
-            const bucket = ensureBucket(buckets, endpoint);
-            const queued = {
-                key,
-                endpoint,
-                requestUrl: requestUrl.toString(),
-                requestInit: normalizedInit,
-                item,
-                size,
-                resolve,
-                reject
-            };
-            bucket.items.push(queued);
-            bucket.bytes += size;
-            emitDataBatchTransportEvent(onEvent, {
-                type: 'enqueue',
-                endpoint,
-                size: bucket.items.length
-            });
-            if (bucket.items.length >= maxBatchSize || bucket.bytes >= maxBatchBytes) return void flushBucket(endpoint);
-            if (!bucket.timer) bucket.timer = setTimeout(()=>{
-                bucket.timer = null;
-                flushBucket(endpoint);
-            }, flushIntervalMs);
-        });
-        pendingByKey.set(key, promise);
-        return promise;
-    };
-}
+const external_batch_transport_js_namespaceObject = require("./batch-transport.js");
+const external_codec_js_namespaceObject = require("./codec.js");
+const external_invalidation_js_namespaceObject = require("./invalidation.js");
+const external_trace_js_namespaceObject = require("./trace.js");
+const external_types_js_namespaceObject = require("./types.js");
+const external_validation_js_namespaceObject = require("./validation.js");
 exports.DATA_BATCH_TRANSPORT_OTEL_EVENT = __webpack_exports__.DATA_BATCH_TRANSPORT_OTEL_EVENT;
 exports.DEFAULT_DATA_BATCH_ENDPOINT = __webpack_exports__.DEFAULT_DATA_BATCH_ENDPOINT;
 exports.DEFAULT_DATA_BATCH_HEADER = __webpack_exports__.DEFAULT_DATA_BATCH_HEADER;