@clue-ai/browser-sdk 0.0.1

package/dist/capture/network.js

@@ -0,0 +1,903 @@
+import { generateEventId, generateRequestId, generateRequestSpanId, } from "../normalize/event-id";
+import { toPathTemplate } from "../normalize/path-template";
+import { buildLocalQuerySummary, buildLocalStructuredSummary, } from "../privacy/local-minimization";
+import { maybeParseJson, sanitizeHeaders } from "../privacy/sanitize";
+import { buildSchemaEvidence, deriveOutcomeClass, extractErrorCodeCandidate, extractGraphqlEvidence, } from "../privacy/schema-evidence";
+import { hasAuthoringInternalRequestHeader, isAuthoringInternalRequestUrl, logAuthoringRequestExclusion, } from "../authoring/surface";
+import { CLUE_SDK_REQUEST_HEADER } from "../transport/client";
+const XHR_META_KEY = "__clue_xhr_meta__";
+const headersToRecord = (headers) => {
+    if (!headers) {
+        return {};
+    }
+    if (headers instanceof Headers) {
+        const record = {};
+        headers.forEach((value, key) => {
+            record[key] = value;
+        });
+        return record;
+    }
+    if (Array.isArray(headers)) {
+        const record = {};
+        for (const [key, value] of headers) {
+            record[key] = value;
+        }
+        return record;
+    }
+    const record = {};
+    for (const [key, value] of Object.entries(headers)) {
+        record[key] = String(value);
+    }
+    return record;
+};
+const normalizeBody = (body) => {
+    if (body == null) {
+        return null;
+    }
+    if (typeof body === "string") {
+        return maybeParseJson(body) ?? body;
+    }
+    if (body instanceof URLSearchParams) {
+        const asObject = {};
+        body.forEach((value, key) => {
+            const current = asObject[key];
+            if (Array.isArray(current)) {
+                current.push(value);
+            }
+            else if (typeof current === "string") {
+                asObject[key] = [current, value];
+            }
+            else {
+                asObject[key] = value;
+            }
+        });
+        return asObject;
+    }
+    if (typeof FormData !== "undefined" && body instanceof FormData) {
+        const asObject = {};
+        body.forEach((value, key) => {
+            const normalizedValue = typeof value === "string"
+                ? value
+                : {
+                    _type: "file",
+                    mime_type: value.type || null,
+                    size: value.size,
+                };
+            const current = asObject[key];
+            if (Array.isArray(current)) {
+                current.push(normalizedValue);
+            }
+            else if (current !== undefined) {
+                asObject[key] = [current, normalizedValue];
+            }
+            else {
+                asObject[key] = normalizedValue;
+            }
+        });
+        return asObject;
+    }
+    if (typeof Blob !== "undefined" && body instanceof Blob) {
+        return {
+            _type: "blob",
+            mime_type: body.type || null,
+            size: body.size,
+        };
+    }
+    if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) {
+        return {
+            _type: "array_buffer",
+            byte_length: body.byteLength,
+        };
+    }
+    if (ArrayBuffer.isView(body)) {
+        return {
+            _type: "array_buffer_view",
+            byte_length: body.byteLength,
+        };
+    }
+    if (typeof body === "object") {
+        return body;
+    }
+    return null;
+};
+const resolveUrlAgainstCurrentLocation = (value) => {
+    try {
+        return new URL(value);
+    }
+    catch { }
+    const currentHref = typeof globalThis.location?.href === "string" &&
+        globalThis.location.href.length > 0
+        ? globalThis.location.href
+        : null;
+    if (!currentHref) {
+        return null;
+    }
+    try {
+        return new URL(value, currentHref);
+    }
+    catch {
+        return null;
+    }
+};
+const stripQueryFromUrl = (url) => {
+    try {
+        const resolvedUrl = resolveUrlAgainstCurrentLocation(url);
+        if (!resolvedUrl) {
+            return url.split("?")[0] ?? url;
+        }
+        return `${resolvedUrl.origin}${resolvedUrl.pathname}`;
+    }
+    catch {
+        return url.split("?")[0] ?? url;
+    }
+};
+const buildParameterSource = (input) => {
+    const source = {};
+    if (input.headers && Object.keys(input.headers).length > 0) {
+        source.headers = input.headers;
+    }
+    if (input.query && Object.keys(input.query).length > 0) {
+        source.query = input.query;
+    }
+    if (input.body !== null && input.body !== undefined) {
+        source.body = input.body;
+    }
+    return source;
+};
+const buildRequestShapeEvidence = (input) => {
+    const requestSchemaSource = buildParameterSource({
+        query: input.queryValues,
+        body: input.normalizedRequestBody,
+    });
+    const requestSchemaEvidence = buildSchemaEvidence(Object.keys(requestSchemaSource).length > 0 ? requestSchemaSource : null);
+    const graphqlEvidence = extractGraphqlEvidence(input.normalizedRequestBody);
+    return {
+        requestKind: graphqlEvidence.requestKind ?? input.defaultRequestKind,
+        requestSchemaHash: requestSchemaEvidence.schemaHash,
+        requestFieldPaths: requestSchemaEvidence.fieldPaths,
+        requestShapeSize: requestSchemaEvidence.shapeSize,
+        graphqlOperationName: graphqlEvidence.graphqlOperationName,
+        graphqlOperationType: graphqlEvidence.graphqlOperationType,
+        graphqlTopLevelFields: graphqlEvidence.graphqlTopLevelFields,
+    };
+};
+const buildResponseShapeEvidence = (input) => {
+    const responseSchemaEvidence = buildSchemaEvidence(input.normalizedResponseBody);
+    return {
+        outcomeClass: deriveOutcomeClass({
+            statusCode: input.statusCode,
+            failureType: input.failureType,
+            responseBody: input.normalizedResponseBody,
+        }),
+        errorCodeCandidate: extractErrorCodeCandidate(input.normalizedResponseBody),
+        responseSchemaHash: responseSchemaEvidence.schemaHash,
+        responseFieldPaths: responseSchemaEvidence.fieldPaths,
+        responseShapeSize: responseSchemaEvidence.shapeSize,
+    };
+};
+const resolveRequestShape = (rawUrl) => {
+    const resolvedUrl = resolveUrlAgainstCurrentLocation(rawUrl);
+    const path = resolvedUrl?.pathname ?? "/";
+    return {
+        path,
+        pathTemplate: toPathTemplate(path),
+        targetService: resolvedUrl?.host ?? null,
+    };
+};
+const readQueryValues = (rawUrl) => {
+    try {
+        const resolvedUrl = resolveUrlAgainstCurrentLocation(rawUrl);
+        if (!resolvedUrl) {
+            return {};
+        }
+        const queryValues = {};
+        resolvedUrl.searchParams.forEach((value, key) => {
+            const current = queryValues[key];
+            if (current === undefined) {
+                queryValues[key] = value;
+                return;
+            }
+            if (Array.isArray(current)) {
+                queryValues[key] = [...current, value];
+                return;
+            }
+            queryValues[key] = [current, value];
+        });
+        return queryValues;
+    }
+    catch {
+        return {};
+    }
+};
+const estimateBodySizeBytes = (body) => {
+    if (body == null) {
+        return undefined;
+    }
+    if (typeof body === "string") {
+        return new TextEncoder().encode(body).byteLength;
+    }
+    if (typeof Blob !== "undefined" && body instanceof Blob) {
+        return body.size;
+    }
+    if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) {
+        return body.byteLength;
+    }
+    if (ArrayBuffer.isView(body)) {
+        return body.byteLength;
+    }
+    try {
+        return new TextEncoder().encode(JSON.stringify(body)).byteLength;
+    }
+    catch {
+        return undefined;
+    }
+};
+const deriveFailureTypeFromStatus = (status) => {
+    if (status >= 500) {
+        return "server_error";
+    }
+    if (status >= 400) {
+        return "client_error";
+    }
+    return null;
+};
+const PRIVACY_POLICY_VERSION = 1;
+const hasSdkTransportHeader = (headers) => {
+    return typeof headers[CLUE_SDK_REQUEST_HEADER] === "string";
+};
+const shouldEmitImportantFailureResponse = (statusCode, failureType, isImportant4xxPath) => {
+    if (statusCode >= 500) {
+        return true;
+    }
+    if (statusCode >= 400 && statusCode < 500 && isImportant4xxPath) {
+        return true;
+    }
+    if (!failureType) {
+        return false;
+    }
+    return (failureType === "server_error" ||
+        failureType === "network_error" ||
+        failureType === "xhr_error" ||
+        failureType === "xhr_abort" ||
+        failureType === "xhr_timeout" ||
+        failureType === "fetch_error");
+};
+const readResponseBody = async (response) => {
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("application/json")) {
+        return null;
+    }
+    try {
+        const text = await response.text();
+        return maybeParseJson(text);
+    }
+    catch {
+        return null;
+    }
+};
+const getXhrResponseBody = (xhr) => {
+    try {
+        if (xhr.responseType === "" || xhr.responseType === "text") {
+            return maybeParseJson(xhr.responseText);
+        }
+        if (xhr.responseType === "json") {
+            return xhr.response;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+const parseXhrHeaders = (rawHeaders) => {
+    const headers = {};
+    rawHeaders
+        .trim()
+        .split(/\r?\n/)
+        .forEach((line) => {
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex <= 0) {
+            return;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        if (key) {
+            headers[key] = value;
+        }
+    });
+    return headers;
+};
+export const startNetworkCapture = (context, options = {}) => {
+    const ignoreUrlPrefixes = options.ignoreUrlPrefixes ?? [];
+    const tracePropagationOrigins = new Set((options.tracePropagationOrigins ?? []).map((origin) => origin.trim().toLowerCase()));
+    const important4xxPathPrefixes = (options.important4xxPathPrefixes ?? [])
+        .map((prefix) => prefix.trim())
+        .filter(Boolean)
+        .map((prefix) => (prefix.startsWith("/") ? prefix : `/${prefix}`));
+    const createRequestTraceContext = options.createRequestTraceContext ??
+        (() => ({
+            traceId: `trace_${generateEventId()}`,
+            parentSpanId: null,
+            requestId: generateRequestId(),
+            requestSpanId: generateRequestSpanId(),
+            interactionId: null,
+        }));
+    const toTraceHeaders = (traceContext) => {
+        const parentSpanId = traceContext.parentSpanId ?? traceContext.requestId;
+        const observationContext = context.getObservationContext?.() ?? null;
+        const headers = {
+            "x-clue-trace-id": traceContext.traceId,
+            "x-clue-parent-span-id": parentSpanId,
+            "x-clue-request-id": traceContext.requestId,
+            "x-clue-request-span-id": traceContext.requestSpanId,
+        };
+        if (traceContext.interactionId) {
+            headers["x-clue-interaction-id"] = traceContext.interactionId;
+        }
+        if (observationContext?.sessionId) {
+            headers["x-clue-session-id"] = observationContext.sessionId;
+        }
+        if (observationContext?.anonymousId) {
+            headers["x-clue-anonymous-id"] = observationContext.anonymousId;
+        }
+        if (observationContext?.userId) {
+            headers["x-clue-user-id"] = observationContext.userId;
+        }
+        if (observationContext?.accountId) {
+            headers["x-clue-account-id"] = observationContext.accountId;
+        }
+        if (observationContext?.organizationId) {
+            headers["x-clue-organization-id"] = observationContext.organizationId;
+        }
+        if (observationContext?.tabId) {
+            headers["x-clue-tab-id"] = observationContext.tabId;
+        }
+        return headers;
+    };
+    const enrichFetchInitWithTraceHeaders = (init, request, traceHeaders) => {
+        const headers = new Headers(request?.headers);
+        if (init?.headers) {
+            new Headers(init.headers).forEach((value, key) => {
+                headers.set(key, value);
+            });
+        }
+        for (const [key, value] of Object.entries(traceHeaders)) {
+            headers.set(key, value);
+        }
+        return {
+            ...(init ?? {}),
+            headers,
+        };
+    };
+    const shouldIgnoreUrl = (url) => {
+        if (!url) {
+            return false;
+        }
+        return ignoreUrlPrefixes.some((prefix) => prefix && url.startsWith(prefix));
+    };
+    const shouldInjectTraceHeaders = (url) => {
+        if (!url) {
+            return false;
+        }
+        try {
+            const resolvedUrl = resolveUrlAgainstCurrentLocation(url);
+            if (!resolvedUrl) {
+                return false;
+            }
+            const requestOrigin = resolvedUrl.origin.toLowerCase();
+            const currentOrigin = globalThis.location?.origin?.toLowerCase() ?? null;
+            if (currentOrigin && requestOrigin === currentOrigin) {
+                return true;
+            }
+            return tracePropagationOrigins.has(requestOrigin);
+        }
+        catch {
+            return false;
+        }
+    };
+    const parseImportantPathTemplate = (url) => {
+        try {
+            const resolvedUrl = resolveUrlAgainstCurrentLocation(url);
+            if (!resolvedUrl) {
+                return null;
+            }
+            const pathTemplate = toPathTemplate(resolvedUrl.pathname);
+            return important4xxPathPrefixes.some((prefix) => pathTemplate.startsWith(prefix))
+                ? pathTemplate
+                : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const hasFetch = typeof globalThis.fetch === "function";
+    const hasXhr = typeof globalThis.XMLHttpRequest !== "undefined";
+    const originalFetch = hasFetch
+        ? globalThis.fetch.bind(globalThis)
+        : undefined;
+    if (hasFetch && originalFetch) {
+        globalThis.fetch = (async (input, init) => {
+            if (context.getConsent() === "denied") {
+                return originalFetch(input, init);
+            }
+            const startedAtMs = Date.now();
+            const request = input instanceof Request ? input : null;
+            const method = init?.method || (request?.method ? request.method : "GET");
+            const rawUrl = typeof input === "string"
+                ? input
+                : input instanceof URL
+                    ? input.toString()
+                    : input.url;
+            const url = stripQueryFromUrl(rawUrl);
+            const requestShape = resolveRequestShape(rawUrl);
+            if (shouldIgnoreUrl(rawUrl)) {
+                if (isAuthoringInternalRequestUrl(rawUrl)) {
+                    logAuthoringRequestExclusion("ignore_url_prefix");
+                }
+                return originalFetch(input, init);
+            }
+            const traceContext = createRequestTraceContext();
+            const parentSpanId = traceContext.parentSpanId ?? traceContext.requestId;
+            const traceHeaders = toTraceHeaders(traceContext);
+            const enrichedInit = shouldInjectTraceHeaders(rawUrl)
+                ? enrichFetchInitWithTraceHeaders(init, request, traceHeaders)
+                : { ...(init ?? {}) };
+            const requestId = traceContext.requestId;
+            const requestSpanId = traceContext.requestSpanId;
+            const interactionId = traceContext.interactionId;
+            const requestHeaders = {
+                ...headersToRecord(request?.headers),
+                ...headersToRecord(enrichedInit.headers),
+            };
+            if (hasSdkTransportHeader(requestHeaders)) {
+                return originalFetch(input, init);
+            }
+            if (hasAuthoringInternalRequestHeader(requestHeaders)) {
+                logAuthoringRequestExclusion("request_header");
+                return originalFetch(input, init);
+            }
+            const requestBodyRaw = enrichedInit.body ?? null;
+            const normalizedRequestBody = normalizeBody(requestBodyRaw);
+            const queryValues = readQueryValues(rawUrl);
+            const queryKeys = Object.keys(queryValues);
+            const querySummary = buildLocalQuerySummary(queryValues);
+            const requestParametersSource = buildParameterSource({
+                headers: sanitizeHeaders(requestHeaders),
+                query: queryValues,
+                body: normalizedRequestBody,
+            });
+            const requestShapeEvidence = buildRequestShapeEvidence({
+                queryValues,
+                normalizedRequestBody,
+                defaultRequestKind: "fetch",
+            });
+            const requestSizeBytes = estimateBodySizeBytes(requestBodyRaw);
+            const requestMetadataSummary = buildLocalStructuredSummary({
+                headers: requestHeaders,
+                query: querySummary,
+            });
+            try {
+                const response = await originalFetch(input, enrichedInit);
+                const durationMs = Date.now() - startedAtMs;
+                const responseHeaders = headersToRecord(response.headers);
+                const normalizedResponseBody = await readResponseBody(response.clone());
+                const responseParametersSource = buildParameterSource({
+                    headers: sanitizeHeaders(responseHeaders),
+                    body: normalizedResponseBody,
+                });
+                const responseShapeEvidence = buildResponseShapeEvidence({
+                    normalizedResponseBody,
+                    statusCode: response.status,
+                });
+                const contentLength = response.headers.get("content-length");
+                const responseSizeBytes = contentLength && !Number.isNaN(Number(contentLength))
+                    ? Number(contentLength)
+                    : undefined;
+                const failureType = deriveFailureTypeFromStatus(response.status);
+                const important4xxPathTemplate = response.status >= 400 && response.status < 500
+                    ? parseImportantPathTemplate(rawUrl)
+                    : null;
+                if (shouldEmitImportantFailureResponse(response.status, failureType, Boolean(important4xxPathTemplate))) {
+                    const occurredAtMs = Date.now();
+                    context.onEvent({
+                        type: "request_finished",
+                        occurredAtMs,
+                        payload: {
+                            viewId: context.getViewId(),
+                            requestId,
+                            requestSpanId,
+                            interactionId,
+                            method,
+                            url,
+                            path: requestShape.path,
+                            pathTemplate: requestShape.pathTemplate,
+                            targetService: requestShape.targetService,
+                            traceId: traceContext.traceId,
+                            parentSpanId,
+                            statusCode: response.status,
+                            durationMs,
+                            ...requestShapeEvidence,
+                            ...responseShapeEvidence,
+                            requestSizeBytes,
+                            responseSizeBytes,
+                            queryKeys,
+                            requestMetadataSummary,
+                            responseMetadataSummary: buildLocalStructuredSummary({
+                                headers: responseHeaders,
+                            }),
+                            requestParametersSource,
+                            responseParametersSource,
+                            pageUrl: globalThis.location?.href ?? null,
+                            privacyPolicyVersion: PRIVACY_POLICY_VERSION,
+                        },
+                    });
+                    return response;
+                }
+                context.onEvent({
+                    type: "request_finished",
+                    occurredAtMs: Date.now(),
+                    payload: {
+                        viewId: context.getViewId(),
+                        requestId,
+                        requestSpanId,
+                        interactionId,
+                        method,
+                        url,
+                        path: requestShape.path,
+                        pathTemplate: requestShape.pathTemplate,
+                        targetService: requestShape.targetService,
+                        traceId: traceContext.traceId,
+                        parentSpanId,
+                        statusCode: response.status,
+                        durationMs,
+                        ...requestShapeEvidence,
+                        ...responseShapeEvidence,
+                        requestSizeBytes,
+                        responseSizeBytes,
+                        queryKeys,
+                        requestMetadataSummary,
+                        responseMetadataSummary: buildLocalStructuredSummary({
+                            headers: responseHeaders,
+                        }),
+                        requestParametersSource,
+                        responseParametersSource,
+                        pageUrl: globalThis.location?.href ?? null,
+                        privacyPolicyVersion: PRIVACY_POLICY_VERSION,
+                    },
+                });
+                return response;
+            }
+            catch (error) {
+                const durationMs = Date.now() - startedAtMs;
+                const failureType = error instanceof Error ? error.name || "fetch_error" : "fetch_error";
+                const responseShapeEvidence = buildResponseShapeEvidence({
+                    normalizedResponseBody: null,
+                    failureType,
+                });
+                context.onEvent({
+                    type: "request_failed",
+                    occurredAtMs: Date.now(),
+                    payload: {
+                        viewId: context.getViewId(),
+                        requestId,
+                        requestSpanId,
+                        interactionId,
+                        method,
+                        url,
+                        path: requestShape.path,
+                        pathTemplate: requestShape.pathTemplate,
+                        targetService: requestShape.targetService,
+                        traceId: traceContext.traceId,
+                        parentSpanId,
+                        durationMs,
+                        failureType,
+                        ...requestShapeEvidence,
+                        ...responseShapeEvidence,
+                        queryKeys,
+                        requestMetadataSummary,
+                        requestParametersSource,
+                        responseParametersSource: {},
+                        pageUrl: globalThis.location?.href ?? null,
+                        privacyPolicyVersion: PRIVACY_POLICY_VERSION,
+                    },
+                });
+                throw error;
+            }
+        });
+    }
+    let originalOpen = null;
+    let originalSend = null;
+    let originalSetRequestHeader = null;
+    if (hasXhr) {
+        originalOpen = XMLHttpRequest.prototype.open;
+        originalSend = XMLHttpRequest.prototype.send;
+        originalSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+        XMLHttpRequest.prototype.open = function (method, url, async, username, password) {
+            const xhr = this;
+            xhr[XHR_META_KEY] = {
+                method,
+                url: typeof url === "string" ? url : url.toString(),
+                requestHeaders: xhr[XHR_META_KEY]?.requestHeaders ?? {},
+            };
+            const open = originalOpen;
+            if (!open) {
+                return;
+            }
+            open.call(this, method, url, async ?? true, username ?? null, password ?? null);
+        };
+        XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+            const xhr = this;
+            const meta = xhr[XHR_META_KEY] ?? {};
+            const requestHeaders = meta.requestHeaders ?? {};
+            requestHeaders[header] = value;
+            xhr[XHR_META_KEY] = {
+                ...meta,
+                requestHeaders,
+            };
+            const setRequestHeader = originalSetRequestHeader;
+            if (!setRequestHeader) {
+                return;
+            }
+            setRequestHeader.call(this, header, value);
+        };
+        XMLHttpRequest.prototype.send = function (body) {
+            const send = originalSend;
+            if (!send) {
+                return;
+            }
+            if (context.getConsent() === "denied") {
+                send.call(this, body);
+                return;
+            }
+            const xhr = this;
+            const previousMeta = xhr[XHR_META_KEY] ?? {};
+            const startedAtMs = Date.now();
+            const traceContext = createRequestTraceContext();
+            const parentSpanId = traceContext.parentSpanId ?? traceContext.requestId;
+            const requestId = traceContext.requestId;
+            const requestSpanId = traceContext.requestSpanId;
+            const interactionId = traceContext.interactionId;
+            const method = previousMeta.method ?? "GET";
+            const rawUrl = previousMeta.url ?? "";
+            const url = stripQueryFromUrl(rawUrl);
+            const requestShape = resolveRequestShape(rawUrl);
+            if (shouldIgnoreUrl(rawUrl)) {
+                if (isAuthoringInternalRequestUrl(rawUrl)) {
+                    logAuthoringRequestExclusion("ignore_url_prefix");
+                }
+                send.call(this, body);
+                return;
+            }
+            const requestHeaders = previousMeta.requestHeaders ?? {};
+            if (hasSdkTransportHeader(requestHeaders)) {
+                send.call(this, body);
+                return;
+            }
+            if (hasAuthoringInternalRequestHeader(requestHeaders)) {
+                logAuthoringRequestExclusion("request_header");
+                send.call(this, body);
+                return;
+            }
+            if (shouldInjectTraceHeaders(rawUrl)) {
+                const traceHeaders = toTraceHeaders(traceContext);
+                for (const [header, value] of Object.entries(traceHeaders)) {
+                    if (!requestHeaders[header]) {
+                        xhr.setRequestHeader(header, value);
+                    }
+                }
+            }
+            const normalizedRequestBody = normalizeBody(body);
+            const queryValues = readQueryValues(rawUrl);
+            const queryKeys = Object.keys(queryValues);
+            const querySummary = buildLocalQuerySummary(queryValues);
+            const requestParametersSource = buildParameterSource({
+                headers: sanitizeHeaders(requestHeaders),
+                query: queryValues,
+                body: normalizedRequestBody,
+            });
+            const requestShapeEvidence = buildRequestShapeEvidence({
+                queryValues,
+                normalizedRequestBody,
+                defaultRequestKind: "xhr",
+            });
+            const requestSizeBytes = estimateBodySizeBytes(body);
+            const viewId = context.getViewId();
+            const requestMetadataSummary = buildLocalStructuredSummary({
+                headers: requestHeaders,
+                query: querySummary,
+            });
+            const meta = {
+                method,
+                url,
+                requestHeaders,
+                startedAtMs,
+                requestId,
+                requestSpanId,
+                interactionId,
+                viewId,
+            };
+            xhr[XHR_META_KEY] = meta;
+            let failureEmitted = false;
+            const handleLoadEnd = () => {
+                const durationMs = Date.now() - startedAtMs;
+                const status = xhr.status;
+                if (status === 0) {
+                    if (failureEmitted) {
+                        return;
+                    }
+                    failureEmitted = true;
+                    context.onEvent({
+                        type: "request_failed",
+                        occurredAtMs: Date.now(),
+                        payload: {
+                            viewId,
+                            requestId,
+                            requestSpanId,
+                            interactionId,
+                            method,
+                            url,
+                            path: requestShape.path,
+                            pathTemplate: requestShape.pathTemplate,
+                            targetService: requestShape.targetService,
+                            traceId: traceContext.traceId,
+                            parentSpanId,
+                            durationMs,
+                            failureType: "network_error",
+                            ...requestShapeEvidence,
+                            ...buildResponseShapeEvidence({
+                                normalizedResponseBody: null,
+                                failureType: "network_error",
+                            }),
+                            queryKeys,
+                            requestMetadataSummary,
+                            requestParametersSource,
+                            responseParametersSource: {},
+                            privacyPolicyVersion: PRIVACY_POLICY_VERSION,
+                        },
+                    });
+                    return;
+                }
+                const responseHeaders = parseXhrHeaders(xhr.getAllResponseHeaders());
+                const normalizedResponseBody = getXhrResponseBody(xhr);
+                const responseParametersSource = buildParameterSource({
+                    headers: sanitizeHeaders(responseHeaders),
+                    body: normalizedResponseBody,
+                });
+                const responseShapeEvidence = buildResponseShapeEvidence({
+                    normalizedResponseBody,
+                    statusCode: status,
+                });
+                const failureType = deriveFailureTypeFromStatus(status);
+                const important4xxPathTemplate = status >= 400 && status < 500
+                    ? parseImportantPathTemplate(rawUrl)
+                    : null;
+                if (shouldEmitImportantFailureResponse(status, failureType, Boolean(important4xxPathTemplate))) {
+                    const occurredAtMs = Date.now();
+                    context.onEvent({
+                        type: "request_finished",
+                        occurredAtMs,
+                        payload: {
+                            viewId,
+                            requestId,
+                            requestSpanId,
+                            interactionId,
+                            method,
+                            url,
+                            path: requestShape.path,
+                            pathTemplate: requestShape.pathTemplate,
+                            targetService: requestShape.targetService,
+                            traceId: traceContext.traceId,
+                            parentSpanId,
+                            statusCode: status,
+                            durationMs,
+                            ...requestShapeEvidence,
+                            ...responseShapeEvidence,
+                            requestSizeBytes,
+                            queryKeys,
+                            requestMetadataSummary,
+                            responseMetadataSummary: buildLocalStructuredSummary({
+                                headers: responseHeaders,
+                            }),
+                            requestParametersSource,
+                            responseParametersSource,
+                            pageUrl: globalThis.location?.href ?? null,
+                            privacyPolicyVersion: PRIVACY_POLICY_VERSION,
+                        },
+                    });
+                    return;
+                }
+                context.onEvent({
+                    type: "request_finished",
+                    occurredAtMs: Date.now(),
+                    payload: {
+                        viewId,
+                        requestId,
+                        requestSpanId,
+                        interactionId,
+                        method,
+                        url,
+                        path: requestShape.path,
+                        pathTemplate: requestShape.pathTemplate,
+                        targetService: requestShape.targetService,
+                        traceId: traceContext.traceId,
+                        parentSpanId,
+                        statusCode: status,
+                        durationMs,
+                        ...requestShapeEvidence,
+                        ...responseShapeEvidence,
+                        requestSizeBytes,
+                        queryKeys,
+                        requestMetadataSummary,
+                        responseMetadataSummary: buildLocalStructuredSummary({
+                            headers: responseHeaders,
+                        }),
+                        requestParametersSource,
+                        responseParametersSource,
+                        pageUrl: globalThis.location?.href ?? null,
+                        privacyPolicyVersion: PRIVACY_POLICY_VERSION,
+                    },
+                });
+            };
+            const handleFailure = (failureType) => {
+                if (failureEmitted) {
+                    return;
+                }
+                failureEmitted = true;
+                const durationMs = Date.now() - startedAtMs;
+                context.onEvent({
+                    type: "request_failed",
+                    occurredAtMs: Date.now(),
+                    payload: {
+                        viewId,
+                        requestId,
+                        requestSpanId,
+                        interactionId,
+                        method,
+                        url,
+                        path: requestShape.path,
+                        pathTemplate: requestShape.pathTemplate,
+                        targetService: requestShape.targetService,
+                        traceId: traceContext.traceId,
+                        parentSpanId,
+                        durationMs,
+                        failureType,
+                        ...requestShapeEvidence,
+                        ...buildResponseShapeEvidence({
+                            normalizedResponseBody: null,
+                            failureType,
+                        }),
+                        queryKeys,
+                        requestMetadataSummary,
+                        requestParametersSource,
+                        responseParametersSource: {},
+                        pageUrl: globalThis.location?.href ?? null,
+                        privacyPolicyVersion: PRIVACY_POLICY_VERSION,
+                    },
+                });
+            };
+            xhr.addEventListener("loadend", handleLoadEnd, { once: true });
+            xhr.addEventListener("error", () => handleFailure("xhr_error"), {
+                once: true,
+            });
+            xhr.addEventListener("abort", () => handleFailure("xhr_abort"), {
+                once: true,
+            });
+            xhr.addEventListener("timeout", () => handleFailure("xhr_timeout"), {
+                once: true,
+            });
+            send.call(this, body);
+        };
+    }
+    return {
+        stop: () => {
+            if (hasFetch && originalFetch) {
+                globalThis.fetch = originalFetch;
+            }
+            if (hasXhr && originalOpen && originalSend && originalSetRequestHeader) {
+                XMLHttpRequest.prototype.open = originalOpen;
+                XMLHttpRequest.prototype.send = originalSend;
+                XMLHttpRequest.prototype.setRequestHeader = originalSetRequestHeader;
+            }
+        },
+    };
+};