@sentry/browser-utils 10.58.0

package/build/types/metrics/web-vitals/types.d.ts

@@ -0,0 +1,78 @@
+export * from './types/base';
+export * from './types/cls';
+export * from './types/fcp';
+export * from './types/inp';
+export * from './types/lcp';
+export * from './types/ttfb';
+interface PerformanceEntryMap {
+    navigation: PerformanceNavigationTiming;
+    resource: PerformanceResourceTiming;
+    paint: PerformancePaintTiming;
+}
+declare global {
+    interface Document {
+        prerendering?: boolean;
+        wasDiscarded?: boolean;
+    }
+    interface Performance {
+        getEntriesByType<K extends keyof PerformanceEntryMap>(type: K): PerformanceEntryMap[K][];
+    }
+    interface PerformanceObserverInit {
+        durationThreshold?: number;
+    }
+    interface PerformanceNavigationTiming {
+        activationStart?: number;
+    }
+    interface PerformanceEventTiming extends PerformanceEntry {
+        duration: DOMHighResTimeStamp;
+        interactionId: number;
+    }
+    interface LayoutShiftAttribution {
+        node: Node | null;
+        previousRect: DOMRectReadOnly;
+        currentRect: DOMRectReadOnly;
+    }
+    interface LayoutShift extends PerformanceEntry {
+        value: number;
+        sources: LayoutShiftAttribution[];
+        hadRecentInput: boolean;
+    }
+    interface LargestContentfulPaint extends PerformanceEntry {
+        readonly renderTime: DOMHighResTimeStamp;
+        readonly loadTime: DOMHighResTimeStamp;
+        readonly size: number;
+        readonly id: string;
+        readonly url: string;
+        readonly element: Element | null;
+    }
+    export type ScriptInvokerType = 'classic-script' | 'module-script' | 'event-listener' | 'user-callback' | 'resolve-promise' | 'reject-promise';
+    export type ScriptWindowAttribution = 'self' | 'descendant' | 'ancestor' | 'same-page' | 'other';
+    interface PerformanceScriptTiming extends PerformanceEntry {
+        readonly startTime: DOMHighResTimeStamp;
+        readonly duration: DOMHighResTimeStamp;
+        readonly name: string;
+        readonly entryType: string;
+        readonly invokerType: ScriptInvokerType;
+        readonly invoker: string;
+        readonly executionStart: DOMHighResTimeStamp;
+        readonly sourceURL: string;
+        readonly sourceFunctionName: string;
+        readonly sourceCharPosition: number;
+        readonly pauseDuration: DOMHighResTimeStamp;
+        readonly forcedStyleAndLayoutDuration: DOMHighResTimeStamp;
+        readonly window?: Window;
+        readonly windowAttribution: ScriptWindowAttribution;
+    }
+    interface PerformanceLongAnimationFrameTiming extends PerformanceEntry {
+        readonly startTime: DOMHighResTimeStamp;
+        readonly duration: DOMHighResTimeStamp;
+        readonly name: string;
+        readonly entryType: string;
+        readonly renderStart: DOMHighResTimeStamp;
+        readonly styleAndLayoutStart: DOMHighResTimeStamp;
+        readonly blockingDuration: DOMHighResTimeStamp;
+        readonly firstUIEventTimestamp: DOMHighResTimeStamp;
+        readonly scripts: PerformanceScriptTiming[];
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types/metrics/web-vitals/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/metrics/web-vitals/types.ts"],"names":[],"mappings":"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"}

package/build/types/metrics/webVitalSpans.d.ts

@@ -0,0 +1,65 @@
+import type { Client, Span, SpanAttributes } from '@sentry/core';
+import type { WebVitalReportEvent } from './utils';
+import type { PerformanceEventTiming } from './instrument';
+export interface LayoutShift extends PerformanceEntry {
+    value: number;
+    sources: Array<{
+        node: Node | null;
+    }>;
+    hadRecentInput: boolean;
+}
+export interface LargestContentfulPaint extends PerformanceEntry {
+    readonly renderTime: DOMHighResTimeStamp;
+    readonly loadTime: DOMHighResTimeStamp;
+    readonly size: number;
+    readonly id: string;
+    readonly url: string;
+    readonly element: Element | null;
+}
+interface WebVitalSpanOptions {
+    name: string;
+    op: string;
+    origin: string;
+    metricName: 'lcp' | 'cls' | 'inp';
+    value: number;
+    attributes?: SpanAttributes;
+    parentSpan?: Span;
+    reportEvent?: WebVitalReportEvent;
+    startTime: number;
+    endTime?: number;
+}
+/**
+ * Emits a web vital span that flows through the span streaming pipeline.
+ */
+export declare function _emitWebVitalSpan(options: WebVitalSpanOptions): void;
+/**
+ * Tracks LCP as a streamed span.
+ */
+export declare function trackLcpAsSpan(client: Client): void;
+/**
+ * Exported only for testing.
+ */
+export declare function _sendLcpSpan(lcpValue: number, entry: LargestContentfulPaint | undefined, pageloadSpan?: Span, reportEvent?: WebVitalReportEvent): void;
+/**
+ * Tracks CLS as a streamed span.
+ */
+export declare function trackClsAsSpan(client: Client): void;
+/**
+ * Exported only for testing.
+ */
+export declare function _sendClsSpan(clsValue: number, entry: LayoutShift | undefined, pageloadSpan?: Span, reportEvent?: WebVitalReportEvent): void;
+/**
+ * Tracks INP as a streamed span.
+ *
+ * This mirrors the standalone INP tracking logic (`startTrackingINP`) but emits
+ * spans through the streaming pipeline instead of as standalone spans.
+ * Requires `registerInpInteractionListener()` to be called separately for
+ * cached element names and root spans per interaction.
+ */
+export declare function trackInpAsSpan(): void;
+/**
+ * Exported only for testing.
+ */
+export declare function _sendInpSpan(inpValue: number, entry: PerformanceEventTiming): void;
+export {};
+//# sourceMappingURL=webVitalSpans.d.ts.map

package/build/types/metrics/webVitalSpans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webVitalSpans.d.ts","sourceRoot":"","sources":["../../../src/metrics/webVitalSpans.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAqBjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAM3D,MAAM,WAAW,WAAY,SAAQ,gBAAgB;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IACtC,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC9D,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CAClC;AAED,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAiDpE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAqBnD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,sBAAsB,GAAG,SAAS,EACzC,YAAY,CAAC,EAAE,IAAI,EACnB,WAAW,CAAC,EAAE,mBAAmB,GAChC,IAAI,CAiCN;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAqBnD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,WAAW,GAAG,SAAS,EAC9B,YAAY,CAAC,EAAE,IAAI,EACnB,WAAW,CAAC,EAAE,mBAAmB,GAChC,IAAI,CAyBN;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,IAAI,IAAI,CA2BrC;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,sBAAsB,GAAG,IAAI,CA+BlF"}

package/build/types/networkUtils.d.ts

@@ -0,0 +1,25 @@
+import { debug } from '@sentry/core';
+import type { NetworkMetaWarning } from './types';
+export declare const ORIGINAL_REQ_BODY: unique symbol;
+/**
+ * Serializes FormData.
+ *
+ * This is a bit simplified, but gives us a decent estimate.
+ * This converts e.g. { name: 'Anne Smith', age: 13 } to 'name=Anne+Smith&age=13'.
+ *
+ */
+export declare function serializeFormData(formData: FormData): string;
+/** Get the string representation of a body. */
+export declare function getBodyString(body: unknown, _debug?: typeof debug): [string | undefined, NetworkMetaWarning?];
+/**
+ * Parses the fetch arguments to extract the request payload.
+ *
+ * In case of a Request object, this function attempts to retrieve the original body by looking for a Sentry-patched symbol.
+ */
+export declare function getFetchRequestArgBody(fetchArgs?: unknown[]): RequestInit['body'] | undefined;
+/**
+ * Parses XMLHttpRequest response headers into a Record.
+ * Extracted from replay internals to be reusable.
+ */
+export declare function parseXhrResponseHeaders(xhr: XMLHttpRequest): Record<string, string>;
+//# sourceMappingURL=networkUtils.d.ts.map

package/build/types/networkUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkUtils.d.ts","sourceRoot":"","sources":["../../src/networkUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAErC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGlD,eAAO,MAAM,iBAAiB,eAA4C,CAAC;AAE3E;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAG5D;AAED,+CAA+C;AAC/C,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,GAAE,OAAO,KAAa,GAAG,CAAC,MAAM,GAAG,SAAS,EAAE,kBAAkB,CAAC,CAAC,CAyBpH;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,GAAE,OAAO,EAAO,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAoBjG;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoBnF"}

package/build/types/types.d.ts

@@ -0,0 +1,15 @@
+import type { FetchBreadcrumbHint, HandlerDataFetch, SentryWrappedXMLHttpRequest, XhrBreadcrumbHint } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+export declare const WINDOW: typeof GLOBAL_OBJ & Omit<Window, "document"> & Partial<Pick<Window, "document">>;
+export type NetworkMetaWarning = 'MAYBE_JSON_TRUNCATED' | 'TEXT_TRUNCATED' | 'URL_SKIPPED' | 'BODY_PARSE_ERROR' | 'BODY_PARSE_TIMEOUT' | 'UNPARSEABLE_BODY_TYPE';
+type RequestBody = null | Blob | BufferSource | FormData | URLSearchParams | string;
+export type XhrHint = XhrBreadcrumbHint & {
+    xhr: XMLHttpRequest & SentryWrappedXMLHttpRequest;
+    input?: RequestBody;
+};
+export type FetchHint = FetchBreadcrumbHint & {
+    input: HandlerDataFetch['args'];
+    response: Response;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/build/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,2BAA2B,EAC3B,iBAAiB,EAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,MAAM,EAAiB,OAAO,UAAU,GAEnD,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;AAEpC,MAAM,MAAM,kBAAkB,GAC1B,sBAAsB,GACtB,gBAAgB,GAChB,aAAa,GACb,kBAAkB,GAClB,oBAAoB,GACpB,uBAAuB,CAAC;AAE5B,KAAK,WAAW,GAAG,IAAI,GAAG,IAAI,GAAG,YAAY,GAAG,QAAQ,GAAG,eAAe,GAAG,MAAM,CAAC;AAEpF,MAAM,MAAM,OAAO,GAAG,iBAAiB,GAAG;IACxC,GAAG,EAAE,cAAc,GAAG,2BAA2B,CAAC;IAClD,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,CAAC;AACF,MAAM,MAAM,SAAS,GAAG,mBAAmB,GAAG;IAC5C,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC"}

package/build/types-ts3.8/debug-build.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+ *
+ * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+ */
+export declare const DEBUG_BUILD: boolean;
+//# sourceMappingURL=debug-build.d.ts.map

package/build/types-ts3.8/getNativeImplementation.d.ts

@@ -0,0 +1,69 @@
+import { WINDOW } from './types';
+/**
+ * We generally want to use window.fetch / window.setTimeout.
+ * However, in some cases this may be wrapped (e.g. by Zone.js for Angular),
+ * so we try to get an unpatched version of this from a sandboxed iframe.
+ */
+interface CacheableImplementations {
+    setTimeout: typeof WINDOW.setTimeout;
+    fetch: typeof WINDOW.fetch;
+}
+/**
+ * Get the native implementation of a browser function.
+ *
+ * This can be used to ensure we get an unwrapped version of a function, in cases where a wrapped function can lead to problems.
+ *
+ * The following methods can be retrieved:
+ * - `setTimeout`: This can be wrapped by e.g. Angular, causing change detection to be triggered.
+ * - `fetch`: This can be wrapped by e.g. ad-blockers, causing an infinite loop when a request is blocked.
+ */
+export declare function getNativeImplementation<T extends keyof CacheableImplementations>(name: T): CacheableImplementations[T];
+/** Clear a cached implementation. */
+export declare function clearCachedImplementation(name: keyof CacheableImplementations): void;
+/**
+ * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.
+ * Whenever someone wraps the Fetch API and returns the wrong promise chain,
+ * this chain becomes orphaned and there is no possible way to capture it's rejections
+ * other than allowing it bubble up to this very handler. eg.
+ *
+ * const f = window.fetch;
+ * window.fetch = function () {
+ *   const p = f.apply(this, arguments);
+ *
+ *   p.then(function() {
+ *     console.log('hi.');
+ *   });
+ *
+ *   return p;
+ * }
+ *
+ * `p.then(function () { ... })` is producing a completely separate promise chain,
+ * however, what's returned is `p` - the result of original `fetch` call.
+ *
+ * This mean, that whenever we use the Fetch API to send our own requests, _and_
+ * some ad-blocker blocks it, this orphaned chain will _always_ reject,
+ * effectively causing another event to be captured.
+ * This makes a whole process become an infinite loop, which we need to somehow
+ * deal with, and break it in one way or another.
+ *
+ * To deal with this issue, we are making sure that we _always_ use the real
+ * browser Fetch API, instead of relying on what `window.fetch` exposes.
+ * The only downside to this would be missing our own requests as breadcrumbs,
+ * but because we are already not doing this, it should be just fine.
+ *
+ * Possible failed fetch error messages per-browser:
+ *
+ * Chrome:  Failed to fetch
+ * Edge:    Failed to Fetch
+ * Firefox: NetworkError when attempting to fetch resource
+ * Safari:  resource blocked by content blocker
+ */
+export declare function fetch(...rest: Parameters<typeof WINDOW.fetch>): ReturnType<typeof WINDOW.fetch>;
+/**
+ * Get an unwrapped `setTimeout` method.
+ * This ensures that even if e.g. Angular wraps `setTimeout`, we get the native implementation,
+ * avoiding triggering change detection.
+ */
+export declare function setTimeout(...rest: Parameters<typeof WINDOW.setTimeout>): ReturnType<typeof WINDOW.setTimeout>;
+export {};
+//# sourceMappingURL=getNativeImplementation.d.ts.map

package/build/types-ts3.8/htmlTreeAsString.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Given a child DOM element, returns a query-selector statement describing that
+ * and its ancestors
+ * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+export declare function htmlTreeAsString(elem: unknown, options?: string[] | {
+    keyAttrs?: string[];
+    maxStringLength?: number;
+}): string;
+//# sourceMappingURL=htmlTreeAsString.d.ts.map

package/build/types-ts3.8/index.d.ts

@@ -0,0 +1,15 @@
+export { addPerformanceInstrumentationHandler, addClsInstrumentationHandler, addTtfbInstrumentationHandler, addLcpInstrumentationHandler, addInpInstrumentationHandler, } from './metrics/instrument';
+export { addPerformanceEntries, addWebVitalsToSpan, startTrackingInteractions, startTrackingLongTasks, startTrackingLongAnimationFrames, startTrackingWebVitals, startTrackingINP, registerInpInteractionListener, } from './metrics/browserMetrics';
+export { elementTimingIntegration, startTrackingElementTiming } from './metrics/elementTiming';
+export { extractNetworkProtocol } from './metrics/utils';
+export { trackClsAsSpan, trackInpAsSpan, trackLcpAsSpan } from './metrics/webVitalSpans';
+export { addClickKeypressInstrumentationHandler } from './instrument/dom';
+export { addHistoryInstrumentationHandler } from './instrument/history';
+export { fetch, setTimeout, clearCachedImplementation, getNativeImplementation } from './getNativeImplementation';
+export { addXhrInstrumentationHandler, SENTRY_XHR_DATA_KEY } from './instrument/xhr';
+export { getBodyString, getFetchRequestArgBody, serializeFormData, parseXhrResponseHeaders } from './networkUtils';
+export { resourceTimingToSpanAttributes } from './metrics/resourceTiming';
+export { htmlTreeAsString } from './htmlTreeAsString';
+export { isElement } from './is';
+export { FetchHint, NetworkMetaWarning, XhrHint } from './types';
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/instrument/dom.d.ts

@@ -0,0 +1,11 @@
+import { HandlerDataDom } from '@sentry/core';
+/**
+ * Add an instrumentation handler for when a click or a keypress happens.
+ *
+ * Use at your own risk, this might break without changelog notice, only used internally.
+ * @hidden
+ */
+export declare function addClickKeypressInstrumentationHandler(handler: (data: HandlerDataDom) => void): void;
+/** Exported for tests only. */
+export declare function instrumentDOM(): void;
+//# sourceMappingURL=dom.d.ts.map

package/build/types-ts3.8/instrument/history.d.ts

@@ -0,0 +1,15 @@
+import { HandlerDataHistory } from '@sentry/core';
+/**
+ * Add an instrumentation handler for when a fetch request happens.
+ * The handler function is called once when the request starts and once when it ends,
+ * which can be identified by checking if it has an `endTimestamp`.
+ *
+ * Use at your own risk, this might break without changelog notice, only used internally.
+ * @hidden
+ */
+export declare function addHistoryInstrumentationHandler(handler: (data: HandlerDataHistory) => void): void;
+/**
+ * Exported just for testing
+ */
+export declare function instrumentHistory(): void;
+//# sourceMappingURL=history.d.ts.map

package/build/types-ts3.8/instrument/xhr.d.ts

@@ -0,0 +1,14 @@
+import { HandlerDataXhr } from '@sentry/core';
+export declare const SENTRY_XHR_DATA_KEY = "__sentry_xhr_v3__";
+/**
+ * Add an instrumentation handler for when an XHR request happens.
+ * The handler function is called once when the request starts and once when it ends,
+ * which can be identified by checking if it has an `endTimestamp`.
+ *
+ * Use at your own risk, this might break without changelog notice, only used internally.
+ * @hidden
+ */
+export declare function addXhrInstrumentationHandler(handler: (data: HandlerDataXhr) => void): void;
+/** Exported only for tests. */
+export declare function instrumentXHR(): void;
+//# sourceMappingURL=xhr.d.ts.map

package/build/types-ts3.8/is.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks whether given value's type is an Element instance.
+ *
+ * Returns false if `Element` is not available in the current runtime.
+ */
+export declare function isElement(wat: unknown): boolean;
+//# sourceMappingURL=is.d.ts.map

package/build/types-ts3.8/metrics/browserMetrics.d.ts

@@ -0,0 +1,119 @@
+import { Client, Span, SpanAttributes } from '@sentry/core';
+interface StartTrackingWebVitalsOptions {
+    /**
+     * When `true`, CLS is tracked as a standalone span. When `false`, CLS is
+     * recorded as a measurement on the pageload span. When `undefined`, CLS
+     * tracking is skipped entirely (e.g. because span streaming handles it).
+     */
+    recordClsStandaloneSpans: boolean | undefined;
+    /**
+     * When `true`, LCP is tracked as a standalone span. When `false`, LCP is
+     * recorded as a measurement on the pageload span. When `undefined`, LCP
+     * tracking is skipped entirely (e.g. because span streaming handles it).
+     */
+    recordLcpStandaloneSpans: boolean | undefined;
+    client: Client;
+}
+/**
+ * Start tracking web vitals.
+ * The callback returned by this function can be used to stop tracking & ensure all measurements are final & captured.
+ *
+ * @deprecated this function will be removed and streamlined once we stop supporting standalone v1
+ * @returns A function that forces web vitals collection
+ */
+export declare function startTrackingWebVitals({ recordClsStandaloneSpans, recordLcpStandaloneSpans, client, }: StartTrackingWebVitalsOptions): () => void;
+/**
+ * Start tracking long tasks.
+ */
+export declare function startTrackingLongTasks(): void;
+/**
+ * Start tracking long animation frames.
+ */
+export declare function startTrackingLongAnimationFrames(): void;
+/**
+ * Start tracking interaction events.
+ */
+export declare function startTrackingInteractions(): void;
+export { registerInpInteractionListener, startTrackingINP } from './inp';
+interface AddPerformanceEntriesOptions {
+    /**
+     * Resource spans with `op`s matching strings in the array will not be emitted.
+     *
+     * Default: []
+     */
+    ignoreResourceSpans: Array<'resouce.script' | 'resource.css' | 'resource.img' | 'resource.other' | string>;
+    /**
+     * Performance spans created from browser Performance APIs,
+     * `performance.mark(...)` nand `performance.measure(...)`
+     * with `name`s matching strings in the array will not be emitted.
+     *
+     * Default: []
+     */
+    ignorePerformanceApiSpans: Array<string | RegExp>;
+    /**
+     * Whether span streaming is enabled.
+     */
+    spanStreamingEnabled?: boolean;
+}
+interface AddWebVitalsToSpanOptions {
+    /**
+     * Flag to determine if CLS should be recorded as a measurement on the pageload span or
+     * sent as a standalone span instead.
+     * Sending it as a standalone span will yield more accurate LCP values.
+     *
+     * Default: `false` for backwards compatibility.
+     */
+    recordClsOnPageloadSpan: boolean;
+    /**
+     * Flag to determine if LCP should be recorded as a measurement on the pageload span or
+     * sent as a standalone span instead.
+     * Sending it as a standalone span will yield more accurate LCP values.
+     *
+     * Default: `false` for backwards compatibility.
+     */
+    recordLcpOnPageloadSpan: boolean;
+    /**
+     * Whether span streaming is enabled.
+     */
+    spanStreamingEnabled?: boolean;
+}
+/** Add performance related spans to a transaction */
+export declare function addPerformanceEntries(span: Span, options: AddPerformanceEntriesOptions): void;
+/**
+ * Writes the collected web vitals (LCP, CLS, INP, TTFB, FP, FCP) onto the pageload span,
+ * either as measurements/attributes (v1) or as web vital attributes (span streaming).
+ *
+ * This should be called when the pageload span ends, after the web vitals have been finalized.
+ * It is a no-op for non-pageload spans, but always resets the collected web vital state so it
+ * doesn't leak into a subsequent navigation.
+ */
+export declare function addWebVitalsToSpan(span: Span, options: AddWebVitalsToSpanOptions): void;
+/**
+ * Create measure related spans.
+ * Exported only for tests.
+ */
+export declare function _addMeasureSpans(span: Span, entry: PerformanceEntry, startTime: number, duration: number, timeOrigin: number, ignorePerformanceApiSpans: AddPerformanceEntriesOptions['ignorePerformanceApiSpans']): void;
+/**
+ * Instrument navigation entries
+ * exported only for tests
+ */
+export declare function _addNavigationSpans(span: Span, entry: PerformanceNavigationTiming, timeOrigin: number): void;
+/**
+ * Create resource-related spans.
+ * Exported only for tests.
+ */
+export declare function _addResourceSpans(span: Span, entry: PerformanceResourceTiming, resourceUrl: string, startTime: number, duration: number, timeOrigin: number, ignoredResourceSpanOps?: Array<string>): void;
+type ExperimentalResourceTimingProperty = 'renderBlockingStatus' | 'deliveryType' | 'responseStatus';
+/**
+ * Use this to set any attributes we can take directly form the PerformanceResourceTiming entry.
+ *
+ * This is just a mapping function for entry->attribute to keep bundle-size minimal.
+ * Experimental properties are also accepted (see {@link ExperimentalResourceTimingProperty}).
+ * Assumes that all entry properties might be undefined for browser-specific differences.
+ * Only accepts string and number values for now and also sets 0-values.
+ */
+export declare function _setResourceRequestAttributes(entry: Partial<PerformanceResourceTiming> & Partial<Record<ExperimentalResourceTimingProperty, number | string>>, attributes: SpanAttributes, properties: [
+    keyof PerformanceResourceTiming | ExperimentalResourceTimingProperty,
+    string
+][]): void;
+//# sourceMappingURL=browserMetrics.d.ts.map

package/build/types-ts3.8/metrics/cls.d.ts

@@ -0,0 +1,17 @@
+import { Client } from '@sentry/core';
+import { WebVitalReportEvent } from './utils';
+/**
+ * Starts tracking the Cumulative Layout Shift on the current page and collects the value once
+ *
+ * - the page visibility is hidden
+ * - a navigation span is started (to stop CLS measurement for SPA soft navigations)
+ *
+ * Once either of these events triggers, the CLS value is sent as a standalone span and we stop
+ * measuring CLS.
+ */
+export declare function trackClsAsStandaloneSpan(client: Client): void;
+/**
+ * Exported only for testing!
+ */
+export declare function _sendStandaloneClsSpan(clsValue: number, entry: LayoutShift | undefined, pageloadSpanId: string, reportEvent: WebVitalReportEvent): void;
+//# sourceMappingURL=cls.d.ts.map

package/build/types-ts3.8/metrics/elementTiming.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Captures [Element Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceElementTiming)
+ * data as Sentry metrics.
+ *
+ * To mark an element for tracking, add the `elementtiming` HTML attribute:
+ * ```html
+ * <img src="hero.jpg" elementtiming="hero-image" />
+ * <p elementtiming="hero-text">Welcome!</p>
+ * ```
+ *
+ * This emits `ui.element.render_time` and `ui.element.load_time` (for images)
+ * as distribution metrics, tagged with the element's identifier and paint type.
+ */
+export declare const elementTimingIntegration: () => import("@sentry/core").Integration;
+/**
+ * @deprecated Use `elementTimingIntegration` instead. This function is a no-op and will be removed in a future version.
+ */
+export declare function startTrackingElementTiming(): () => void;
+//# sourceMappingURL=elementTiming.d.ts.map

package/build/types-ts3.8/metrics/inp.d.ts

@@ -0,0 +1,35 @@
+import { Span } from '@sentry/core';
+import { InstrumentationHandlerCallback } from './instrument';
+interface InteractionContext {
+    span: Span | undefined;
+    elementName: string;
+}
+/**
+ * 60 seconds is the maximum for a plausible INP value
+ * (source: Me)
+ */
+export declare const MAX_PLAUSIBLE_INP_DURATION = 60;
+/**
+ * Start tracking INP webvital events.
+ */
+export declare function startTrackingINP(): () => void;
+export declare const INP_ENTRY_MAP: Record<string, 'click' | 'hover' | 'drag' | 'press'>;
+/** Starts tracking the Interaction to Next Paint on the current page. #
+ * exported only for testing
+ */
+export declare function _trackINP(): () => void;
+/**
+ * exported only for testing
+ */
+export declare const _onInp: InstrumentationHandlerCallback;
+/**
+ * Look up a cached interaction context (element name + root span) by interactionId.
+ * Returns undefined if no context was cached for this interaction.
+ */
+export declare function getCachedInteractionContext(interactionId: number | undefined): InteractionContext | undefined;
+/**
+ * Register a listener to cache route information for INP interactions.
+ */
+export declare function registerInpInteractionListener(): void;
+export {};
+//# sourceMappingURL=inp.d.ts.map