@sourav732/error-tracker-js 0.0.0-stage → 0.2.0

package/dist/types/collectors/breadcrumbCollector.d.ts

@@ -0,0 +1,45 @@
+import { Logger } from '../core/logger';
+import { CapturedError, Collector, CollectorSink } from './collector';
+import { NetworkInterceptor } from './networkInterceptor';
+/**
+ * Turns a `console.error(...)` call into an error. If one of the arguments is
+ * an Error, its own type and stack are used. Returns null when that Error was
+ * already reported (frameworks often log errors they have just rethrown).
+ */
+export declare function consoleErrorFromArgs(args: unknown[], callStack: string | undefined): CapturedError | null;
+/** Returns true if `el` or an ancestor matches any selector. Invalid selectors are ignored. */
+export declare function isMasked(el: Element, selectors: readonly string[]): boolean;
+/** Short CSS path such as `form#checkout > div.actions > button.primary`. */
+export declare function cssPath(el: Element): string;
+/** Human-readable label for a clicked element, never exposing form values or masked text. */
+export declare function describeElementText(el: Element, maskSelectors: readonly string[]): string;
+/**
+ * Records clicks, navigations, page visibility changes, console warnings and
+ * errors, and network requests as breadcrumbs.
+ */
+export declare class BreadcrumbCollector implements Collector {
+    private readonly sink;
+    private readonly network;
+    private readonly maskSelectors;
+    private readonly logger;
+    /** Also report `console.error` calls as error events (opt-in). */
+    private readonly captureConsoleErrors;
+    private installed;
+    private lastUrl;
+    private originalPushState;
+    private originalReplaceState;
+    private originalConsole;
+    private inConsoleHook;
+    private readonly handleClick;
+    private readonly handlePopState;
+    private readonly handleVisibility;
+    constructor(sink: CollectorSink, network: NetworkInterceptor, maskSelectors: readonly string[], logger: Logger, 
+    /** Also report `console.error` calls as error events (opt-in). */
+    captureConsoleErrors?: boolean);
+    install(): void;
+    uninstall(): void;
+    private recordClick;
+    private recordNavigation;
+    private wrapHistory;
+    private wrapConsole;
+}

package/dist/types/collectors/collector.d.ts

@@ -0,0 +1,22 @@
+import { BreadcrumbInput, ErrorPayload, JsonObject, StackFrame } from '../types';
+/** Lifecycle shared by every collector. Both methods must be idempotent and never throw. */
+export interface Collector {
+    install(): void;
+    uninstall(): void;
+}
+/** An error ready to be turned into an event. */
+export interface CapturedError {
+    error: ErrorPayload;
+    stacktrace: StackFrame[];
+    /** Extra details attached as the event's `context` (e.g. CSP directive, request failure kind). */
+    context?: JsonObject | null;
+}
+/** Kinds of performance problems that produce their own `performance` event. */
+export type PerformanceIssueKind = 'SlowPageLoad' | 'SlowApiCall' | 'MemoryLeakSuspected' | 'MainThreadBlocked' | 'LowFrameRate';
+/** Callbacks collectors use to hand data to the client. */
+export interface CollectorSink {
+    onError(captured: CapturedError): void;
+    onBreadcrumb(breadcrumb: BreadcrumbInput): void;
+    onPerformanceIssue(kind: PerformanceIssueKind, message: string): void;
+    onNavigation(): void;
+}

package/dist/types/collectors/cspCollector.d.ts

@@ -0,0 +1,63 @@
+import { Logger } from '../core/logger';
+import { CapturedError, Collector, CollectorSink } from './collector';
+/** The fields shared by `SecurityPolicyViolationEvent` and the Reporting API's CSP report body. */
+export interface CspViolation {
+    blocked: string;
+    directive: string;
+    disposition: string | null;
+    sourceFile: string | null;
+    lineNumber: number | null;
+    columnNumber: number | null;
+}
+/** Reporting API `csp-violation` report body (not in every TypeScript DOM lib). */
+interface CspReportBody {
+    blockedURL?: string | null;
+    effectiveDirective?: string;
+    disposition?: string;
+    sourceFile?: string | null;
+    lineNumber?: number | null;
+    columnNumber?: number | null;
+}
+interface ReportLike {
+    type: string;
+    body: unknown;
+}
+type ReportingObserverConstructor = new (callback: (reports: ReportLike[]) => void, options: {
+    types: string[];
+    buffered: boolean;
+}) => {
+    observe(): void;
+    disconnect(): void;
+};
+export declare function violationFromEvent(event: SecurityPolicyViolationEvent): CspViolation;
+export declare function violationFromReport(body: CspReportBody): CspViolation;
+/** Builds the error for one Content-Security-Policy violation. */
+export declare function cspError(violation: CspViolation): CapturedError;
+/**
+ * Reports Content-Security-Policy violations (enforced and report-only),
+ * such as a blocked third-party script, an inline script without a nonce or
+ * a disallowed `eval`.
+ *
+ * Where the Reporting API exists (Chromium), a buffered `ReportingObserver`
+ * is used: it also delivers violations that happened while the page's HTML
+ * was still loading, before the SDK started. Other browsers fall back to the
+ * `securitypolicyviolation` event, which only sees violations after init.
+ */
+export declare class CspCollector implements Collector {
+    private readonly sink;
+    private readonly logger;
+    private readonly reportingObserver;
+    private installed;
+    private observer;
+    private readonly handleEvent;
+    private readonly handleReports;
+    constructor(sink: CollectorSink, logger: Logger, 
+    /**
+     * Scripts loaded by the SDK itself (the screenshot library). Violations
+     * they cause, e.g. drawing `data:` images under a strict `img-src`, are not the app's problem.
+     */
+    sdkScriptUrls?: readonly string[], reportingObserver?: ReportingObserverConstructor | null);
+    install(): void;
+    uninstall(): void;
+}
+export {};

package/dist/types/collectors/errorCollector.d.ts

@@ -0,0 +1,26 @@
+import { Logger } from '../core/logger';
+import { CapturedError, Collector, CollectorSink } from './collector';
+/**
+ * Converts any thrown value into an error payload plus parsed stack trace.
+ * Used for global handlers and for `captureError()`.
+ */
+export declare function captureFromThrown(thrown: unknown, handled: boolean, fallbackType?: string): CapturedError;
+/**
+ * Captures uncaught exceptions, unhandled promise rejections and failed
+ * resource loads (scripts, images, stylesheets).
+ *
+ * A capture-phase `error` listener is used rather than assigning
+ * `window.onerror`: it receives the same ErrorEvent, cannot be overwritten by
+ * the host app reassigning `onerror`, and also sees resource load failures,
+ * which do not bubble to `onerror`.
+ */
+export declare class ErrorCollector implements Collector {
+    private readonly sink;
+    private installed;
+    private readonly handleError;
+    private readonly handleRejection;
+    constructor(sink: CollectorSink, logger: Logger);
+    install(): void;
+    uninstall(): void;
+    private fromErrorEvent;
+}

package/dist/types/collectors/httpErrorCollector.d.ts

@@ -0,0 +1,34 @@
+import { ApiCall } from '../types';
+import { CapturedError, Collector, CollectorSink } from './collector';
+import { NetworkInterceptor, RequestDetails } from './networkInterceptor';
+/** Builds the error for a response with an error status, e.g. `GET /api/cart → 500`. */
+export declare function httpErrorFromCall(call: ApiCall, details?: RequestDetails): CapturedError;
+/** Builds the error for a request that never got a response. */
+export declare function networkErrorFromCall(call: ApiCall, details: RequestDetails): CapturedError;
+export interface HttpErrorOptions {
+    /** Report 4xx/5xx responses. */
+    httpErrors: boolean;
+    /** Report requests that got no response (except user aborts). */
+    networkErrors: boolean;
+}
+/**
+ * Turns failed fetch/XHR requests into `error` events:
+ * - `HttpError` for responses with a 4xx or 5xx status;
+ * - `NetworkError` for requests that never got a response (offline, timeout,
+ *   connection refused, DNS/SSL failure, CORS). Requests the app cancelled
+ *   itself are not errors and are skipped.
+ *
+ * Each event's stack trace points at the line of app code that made the request.
+ * The rejection value of a failed fetch is marked as reported, so if the app
+ * leaves that promise uncaught it is not reported a second time.
+ */
+export declare class HttpErrorCollector implements Collector {
+    private readonly sink;
+    private readonly network;
+    private readonly options;
+    private installed;
+    constructor(sink: CollectorSink, network: NetworkInterceptor, options: HttpErrorOptions);
+    install(): void;
+    uninstall(): void;
+    private handle;
+}

package/dist/types/collectors/jsonResponseCollector.d.ts

@@ -0,0 +1,24 @@
+import { Logger } from '../core/logger';
+import { CapturedError, Collector, CollectorSink } from './collector';
+/** Builds the error for a response body that could not be parsed as JSON. */
+export declare function invalidJsonError(url: string, status: number, cause: unknown, callStack: string | undefined): CapturedError;
+/**
+ * Reports responses whose body is not valid JSON when the app calls
+ * `response.json()`, even if the app catches the resulting SyntaxError.
+ * A malformed body from an API is a bug on one side or the other, so it is
+ * worth knowing about either way.
+ *
+ * Only parse failures (SyntaxError) are reported; aborted or already-read
+ * bodies are left alone. The error object is marked as reported so an
+ * uncaught rejection of it is not reported a second time.
+ */
+export declare class JsonResponseCollector implements Collector {
+    private readonly sink;
+    private readonly logger;
+    private readonly isSdkUrl;
+    private original;
+    private patched;
+    constructor(sink: CollectorSink, logger: Logger, isSdkUrl: (url: string) => boolean);
+    install(): void;
+    uninstall(): void;
+}

package/dist/types/collectors/memoryCollector.d.ts

@@ -0,0 +1,38 @@
+import { Logger } from '../core/logger';
+import { MemoryPayload } from '../types';
+import { Collector, CollectorSink } from './collector';
+/** One heap sample, in bytes. */
+export interface MemoryReading {
+    usedBytes: number;
+    totalBytes: number;
+}
+/** Reads `performance.memory`, which only Chromium-based browsers provide. */
+export declare function readChromeMemory(): MemoryReading | null;
+/**
+ * True when the last N readings grow strictly and the newest is more than
+ * the growth threshold above the oldest of the N.
+ */
+export declare function isLeakPattern(usedBytes: readonly number[], consecutive?: number, threshold?: number): boolean;
+/**
+ * Polls JS heap usage every 30 s and flags a suspected leak when the heap
+ * grows by more than 20% across 3 consecutive readings with no navigation in
+ * between. Readings reset on every navigation.
+ */
+export declare class MemoryCollector implements Collector {
+    private readonly sink;
+    private readonly read;
+    private readonly intervalMs;
+    private timer;
+    private readings;
+    private latest;
+    private leakSuspected;
+    private readonly poll;
+    constructor(sink: CollectorSink, logger: Logger, read?: () => MemoryReading | null, intervalMs?: number);
+    install(): void;
+    uninstall(): void;
+    /** Called on navigation: a new page means a new baseline. */
+    resetBaseline(): void;
+    /** Takes one reading; exposed for tests. */
+    sample(): void;
+    snapshot(): MemoryPayload;
+}

package/dist/types/collectors/networkInterceptor.d.ts

@@ -0,0 +1,54 @@
+import { Logger } from '../core/logger';
+import { ApiCall, StackFrame } from '../types';
+import { Collector } from './collector';
+/**
+ * Why a request ended without a response.
+ * - `offline`: the browser reported no connectivity.
+ * - `timeout`: the request timed out (`AbortSignal.timeout()`, `xhr.timeout`).
+ * - `aborted`: the app cancelled it (`AbortController.abort()`, `xhr.abort()`).
+ * - `network`: anything else the browser hides behind one generic error:
+ *   connection refused, DNS failure, TLS/SSL failure, CORS rejection.
+ */
+export type NetworkFailure = 'offline' | 'timeout' | 'aborted' | 'network';
+/** Extra information about a request, beyond the schema's `ApiCall` fields. */
+export interface RequestDetails {
+    /** Set when no HTTP response was received; `null` when one was. */
+    failure: NetworkFailure | null;
+    /** The value fetch rejected with, when it rejected. */
+    error: unknown;
+    /** Where in the app the request was made (SDK frames removed). Parsed lazily. */
+    callSite(): StackFrame[];
+}
+export type NetworkListener = (call: ApiCall, details: RequestDetails) => void;
+/** Classifies a fetch rejection. */
+export declare function classifyFetchFailure(error: unknown): NetworkFailure;
+/**
+ * Wraps `fetch` and `XMLHttpRequest` once and fans each completed request out
+ * to listeners (breadcrumbs, performance, HTTP/network errors). Requests to
+ * the SDK's own endpoint are ignored. Query strings are stripped from
+ * recorded URLs.
+ *
+ * The wrappers never alter request or response behaviour; listener failures
+ * are isolated from the host app's request.
+ */
+export declare class NetworkInterceptor implements Collector {
+    private readonly logger;
+    private listeners;
+    private installed;
+    private originalFetch;
+    private patchedFetch;
+    private originalOpen;
+    private originalSend;
+    private patchedOpen;
+    private patchedSend;
+    private readonly ignoredUrl;
+    constructor(sdkEndpoint: string, logger: Logger);
+    subscribe(listener: NetworkListener): void;
+    /** True for the SDK's own ingestion endpoint, which must never be tracked. */
+    isSdkUrl(rawUrl: string): boolean;
+    install(): void;
+    uninstall(): void;
+    private emit;
+    private wrapFetch;
+    private wrapXhr;
+}

package/dist/types/collectors/performanceCollector.d.ts

@@ -0,0 +1,50 @@
+import { Logger } from '../core/logger';
+import { ApiCall, PerformancePayload } from '../types';
+import { Collector, CollectorSink } from './collector';
+import { NetworkInterceptor } from './networkInterceptor';
+/** Raw page timings, already relative to navigation start. */
+export interface PageTimings {
+    pageLoadMs: number | null;
+    ttfbMs: number | null;
+}
+/** Reads load time and TTFB from Navigation Timing Level 2, falling back to Level 1. */
+export declare function readPageTimings(perf: Performance): PageTimings;
+/** Tracks CLS using the web-vitals "session window" definition. */
+export declare class ClsTracker {
+    private sessionValue;
+    private sessionStart;
+    private sessionLast;
+    private max;
+    private seen;
+    add(value: number, startTime: number, hadRecentInput: boolean): void;
+    value(): number | null;
+}
+/**
+ * Collects page-load metrics (load time, TTFB, FCP, LCP, CLS) and the duration
+ * of every fetch/XHR call. Reports a `performance` event when the page load
+ * exceeds 3 s or an API call exceeds 2 s.
+ */
+export declare class PerformanceCollector implements Collector {
+    private readonly sink;
+    private readonly network;
+    private readonly logger;
+    private installed;
+    private metrics;
+    private readonly apiCalls;
+    private readonly slowApiCalls;
+    private readonly cls;
+    private observers;
+    private lcpFinal;
+    private readonly handleLoad;
+    private readonly finalizeLcp;
+    constructor(sink: CollectorSink, network: NetworkInterceptor, logger: Logger);
+    install(): void;
+    uninstall(): void;
+    /** Current metrics for inclusion in a payload. */
+    snapshot(): PerformancePayload;
+    /** Records a completed request; exposed so it can be unit-tested without patching fetch. */
+    recordApiCall(call: ApiCall): void;
+    /** Reads navigation timings; exposed for tests. */
+    measurePageLoad(): void;
+    private observe;
+}

package/dist/types/collectors/resourceCollector.d.ts

@@ -0,0 +1,45 @@
+import { Logger } from '../core/logger';
+import { CapturedError, Collector, CollectorSink } from './collector';
+/** A resource timing entry. `responseStatus` is Chromium 109+, so it may be missing at runtime. */
+type ResourceEntryWithStatus = PerformanceEntry & {
+    initiatorType: string;
+    responseEnd: number;
+    responseStatus?: number;
+};
+/** Builds the error for an element resource that failed before the SDK started. */
+export declare function earlyElementResourceError(tag: string, url: string, status: number): CapturedError;
+/** Builds the error for a stylesheet-initiated resource that came back with an error status. */
+export declare function cssResourceError(url: string, status: number): CapturedError;
+/** Builds the error for a web font that failed to load or decode. */
+export declare function fontError(family: string): CapturedError;
+/**
+ * Covers resource failures that never fire an element `error` event, so the
+ * error collector cannot see them:
+ * - **Web fonts** (`@font-face`, `new FontFace()`): via `document.fonts`
+ *   `loadingerror`, in all modern browsers.
+ * - **CSS background images and `@import`ed files** with a 4xx/5xx status:
+ *   via Resource Timing `responseStatus`.
+ * - **`<img>`, `<script>` and `<link>` failures from before the SDK started**
+ *   (e.g. a broken image in the server-rendered HTML): read from the buffered
+ *   Resource Timing entries at startup.
+ *
+ * Resource Timing status is Chromium 109+ only, and only for same-origin
+ * resources or ones served with `Timing-Allow-Origin`.
+ */
+export declare class ResourceCollector implements Collector {
+    private readonly sink;
+    private readonly logger;
+    private observer;
+    private fonts;
+    /** performance.now() at install; element failures that finished earlier were missed by the error collector. */
+    private installedAt;
+    private earlyReported;
+    private readonly handleFontError;
+    constructor(sink: CollectorSink, logger: Logger);
+    install(): void;
+    uninstall(): void;
+    /** Handles one resource timing entry; exposed for tests. */
+    recordResource(entry: ResourceEntryWithStatus): void;
+    private observeCssResources;
+}
+export {};

package/dist/types/collectors/responsivenessCollector.d.ts

@@ -0,0 +1,45 @@
+import { Logger } from '../core/logger';
+import { Collector, CollectorSink } from './collector';
+export interface ResponsivenessDependencies {
+    now?: () => number;
+    requestFrame?: (callback: () => void) => void;
+    sampleIntervalMs?: number;
+}
+/**
+ * Watches main-thread responsiveness:
+ * - **Freezes:** uses the Long Tasks API (Chromium browsers only) and reports
+ *   a `MainThreadBlocked` performance event when one task blocks the page for
+ *   longer than 1 s. At most one report per 30 s.
+ * - **Frame rate:** 5 s after start and then every 30 s, while the page is
+ *   visible, counts animation frames for 1 s. The latest value fills `performance.frame_rate_fps`, and a
+ *   sample under 20 fps is reported as `LowFrameRate`.
+ *
+ * A page stuck in an infinite loop never finishes its task, so it cannot be
+ * reported from inside the page.
+ */
+export declare class ResponsivenessCollector implements Collector {
+    private readonly sink;
+    private readonly logger;
+    private observer;
+    private timer;
+    private firstSampleTimer;
+    private sampling;
+    private fps;
+    private lastFreezeReport;
+    private lastLowFpsReport;
+    private readonly now;
+    private readonly requestFrame;
+    private readonly sampleIntervalMs;
+    private readonly runSample;
+    constructor(sink: CollectorSink, logger: Logger, deps?: ResponsivenessDependencies);
+    install(): void;
+    uninstall(): void;
+    /** Latest sampled frame rate, or null if none was measured yet. */
+    frameRate(): number | null;
+    /** Handles one long task; exposed for tests. */
+    recordLongTask(durationMs: number): void;
+    /** Counts frames for one sample window; exposed for tests. */
+    sampleFrameRate(): void;
+    private recordFrameRate;
+    private observeLongTasks;
+}

package/dist/types/collectors/screenshotCollector.d.ts

@@ -0,0 +1,52 @@
+import { Logger } from '../core/logger';
+/** The subset of html2canvas options the SDK uses. */
+export interface Html2CanvasOptions {
+    logging: boolean;
+    useCORS: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    scale: number;
+    onclone: (clonedDocument: Document) => void;
+}
+export type Html2Canvas = (element: HTMLElement, options: Html2CanvasOptions) => Promise<HTMLCanvasElement>;
+export interface ScreenshotOptions {
+    maskSelectors: readonly string[];
+    libraryUrl: string;
+    /** SRI hash for `libraryUrl`; empty string disables the integrity attribute. */
+    libraryIntegrity: string;
+}
+/** Returns every element matching any selector. Invalid selectors are skipped. */
+export declare function findMaskedElements(root: ParentNode, selectors: readonly string[]): Element[];
+/**
+ * Pre-render masking applied to html2canvas's cloned DOM: masked elements are
+ * painted solid black and form values are blanked, so their content never
+ * reaches the renderer. The live page is not touched.
+ */
+export declare function maskClonedDocument(clone: Document, selectors: readonly string[]): void;
+/**
+ * Post-render masking: draws an opaque rectangle over each masked element's
+ * on-screen bounds. Belt-and-braces with `maskClonedDocument`.
+ */
+export declare function paintMasks(ctx: CanvasRenderingContext2D, elements: Element[], scale: number): void;
+/**
+ * Captures the visible viewport as a JPEG data URL using html2canvas, which
+ * is loaded from a CDN on first use (it is never bundled with the SDK).
+ * Elements matching the mask selectors are blacked out.
+ *
+ * Screenshots are skipped when the page is hidden, when one was taken in the
+ * last 10 s, or when capture takes longer than 3 s.
+ */
+export declare class ScreenshotCollector {
+    private readonly options;
+    private readonly logger;
+    private readonly clock;
+    private loader;
+    private lastCaptureAt;
+    constructor(options: ScreenshotOptions, logger: Logger, clock?: () => number);
+    /** Resolves to a data URL, or `null` if no screenshot could or should be taken. Never rejects. */
+    capture(): Promise<string | null>;
+    private render;
+    private loadLibrary;
+}

package/dist/types/collectors/workerCollector.d.ts

@@ -0,0 +1,22 @@
+import { Logger } from '../core/logger';
+import { CapturedError, Collector, CollectorSink } from './collector';
+/** Builds the error for an `error` event fired on a Worker object. */
+export declare function workerErrorFromEvent(event: Event, workerUrl: string): CapturedError;
+/**
+ * Reports uncaught errors inside dedicated Web Workers, and workers that fail
+ * to load. Errors inside a worker never reach the page's `window` error
+ * handler in every browser, so `window.Worker` is wrapped to attach an
+ * `error` listener to each worker the app creates. The returned object is the
+ * real Worker, so `instanceof Worker` and all behaviour are unchanged.
+ *
+ * Service Worker errors are not visible from the page and are not covered.
+ */
+export declare class WorkerCollector implements Collector {
+    private readonly sink;
+    private readonly logger;
+    private original;
+    private patched;
+    constructor(sink: CollectorSink, logger: Logger);
+    install(): void;
+    uninstall(): void;
+}

package/dist/types/constants.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Every tunable number and fixed string used by the SDK lives here.
+ * Nothing else in the codebase should contain a bare threshold, timeout or limit.
+ */
+export declare const SDK_NAME = "error-tracker-js";
+/** Must match package.json "version" (a test enforces this). */
+export declare const SDK_VERSION = "0.2.0";
+export declare const PLATFORM = "js";
+export declare const DEFAULT_SAMPLE_RATE = 1;
+export declare const DEFAULT_MAX_BREADCRUMBS = 30;
+/** Hard ceiling so a misconfigured app cannot make every payload huge. */
+export declare const MAX_BREADCRUMBS_LIMIT = 100;
+export declare const DEFAULT_ENVIRONMENT = "production";
+export declare const API_KEY_HEADER = "X-API-Key";
+export declare const CONTENT_TYPE_JSON = "application/json";
+export declare const BATCH_SIZE = 10;
+/**
+ * Max serialized size of one request. Serverless hosts cap request bodies
+ * (Vercel: 4.5 MB); batches are split to stay well below that. A single event
+ * larger than this is still sent on its own.
+ */
+export declare const MAX_BATCH_BYTES = 1000000;
+/** How long to wait for more events before sending a partial batch. */
+export declare const FLUSH_DELAY_MS = 2000;
+/** Backoff before each retry; length of this array is the retry count. */
+export declare const RETRY_DELAYS_MS: readonly number[];
+export declare const REQUEST_TIMEOUT_MS = 30000;
+/** In-memory queue cap; oldest events are dropped beyond this. */
+export declare const MAX_QUEUE_SIZE = 100;
+export declare const OFFLINE_STORAGE_KEY = "_et_queue";
+/** Persisted queue cap; keeps localStorage usage bounded. */
+export declare const MAX_PERSISTED_EVENTS = 50;
+export declare const HTTP_STATUS_REQUEST_TIMEOUT = 408;
+export declare const HTTP_STATUS_TOO_MANY_REQUESTS = 429;
+export declare const HTTP_STATUS_SERVER_ERROR_MIN = 500;
+export declare const HTTP_STATUS_OK_MIN = 200;
+export declare const HTTP_STATUS_OK_MAX = 299;
+/** Max events accepted per rolling window (error-storm protection). */
+export declare const RATE_LIMIT_MAX_EVENTS = 100;
+export declare const RATE_LIMIT_WINDOW_MS = 60000;
+/** Identical events inside this window are dropped as duplicates. */
+export declare const DEDUP_WINDOW_MS = 5000;
+/** Number of distinct fingerprints remembered for dedup. */
+export declare const DEDUP_MAX_ENTRIES = 200;
+/** Calls made to the public API before init() are buffered up to this count. */
+export declare const MAX_PRE_INIT_CALLS = 100;
+/** How long a reported error's text signature suppresses a second copy of the same failure. */
+export declare const REPORTED_SIGNATURE_TTL_MS = 2000;
+/** After the rate limiter starts dropping, a summary event is sent this long after the first drop. */
+export declare const DROPPED_EVENTS_REPORT_DELAY_MS = 10000;
+export declare const MAX_STACK_FRAMES = 50;
+export declare const MAX_SERIALIZE_DEPTH = 5;
+export declare const MAX_SERIALIZE_KEYS = 50;
+export declare const MAX_STRING_LENGTH = 1000;
+export declare const MAX_MESSAGE_LENGTH = 2000;
+export declare const UNKNOWN_FUNCTION = "<anonymous>";
+export declare const MAX_CLICK_TEXT_LENGTH = 50;
+export declare const MAX_CSS_PATH_DEPTH = 5;
+export declare const MASKED_TEXT = "[masked]";
+export declare const SLOW_PAGE_LOAD_MS = 3000;
+export declare const SLOW_API_CALL_MS = 2000;
+/** Responses at or above this status are reported as HttpError events. */
+export declare const HTTP_ERROR_STATUS_MIN = 400;
+/** Number of most recent API calls attached to every payload. */
+export declare const MAX_API_CALLS_TRACKED = 20;
+/** Delay after window `load` so loadEventEnd is populated. */
+export declare const PAGE_LOAD_SETTLE_MS = 0;
+/** CLS session window rules (per the web-vitals definition). */
+export declare const CLS_SESSION_GAP_MS = 1000;
+export declare const CLS_SESSION_MAX_MS = 5000;
+/** A single main-thread task longer than this is reported as a page freeze. */
+export declare const LONG_TASK_FREEZE_MS = 1000;
+/** Minimum gap between two freeze reports, so a sluggish page cannot flood events. */
+export declare const FREEZE_REPORT_INTERVAL_MS = 30000;
+/** Delay before the first frame-rate sample, so page-load work doesn't skew it. */
+export declare const FPS_FIRST_SAMPLE_DELAY_MS = 5000;
+/** How often the frame rate is sampled while the page is visible. */
+export declare const FPS_SAMPLE_INTERVAL_MS = 30000;
+/** How long each frame-rate sample runs. */
+export declare const FPS_SAMPLE_DURATION_MS = 1000;
+/** Sampled frame rates below this are reported as LowFrameRate. Kept well under 30 fps because low-power modes cap at 30. */
+export declare const LOW_FPS_THRESHOLD = 20;
+export declare const MS_PER_SECOND = 1000;
+export declare const MEMORY_POLL_INTERVAL_MS = 30000;
+export declare const LEAK_CONSECUTIVE_READINGS = 3;
+/** Growth ratio across the consecutive readings that flags a leak (20%). */
+export declare const LEAK_GROWTH_THRESHOLD = 0.2;
+export declare const BYTES_PER_MB: number;
+export declare const DEFAULT_HTML2CANVAS_URL = "https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js";
+/** Subresource-integrity hash of DEFAULT_HTML2CANVAS_URL. */
+export declare const DEFAULT_HTML2CANVAS_INTEGRITY = "sha384-ZZ1pncU3bQe8y31yfZdMFdSpttDoPmOZg2wguVK9almUodir1PghgT0eY7Mrty8H";
+export declare const SCREENSHOT_MIME_TYPE = "image/jpeg";
+export declare const SCREENSHOT_QUALITY = 0.5;
+/** Fallback quality used when the first encode is over the size budget. */
+export declare const SCREENSHOT_FALLBACK_QUALITY = 0.3;
+/** Max base64 length of a screenshot data URL (~750 KB). */
+/** Max base64 length of a screenshot data URL (~370 KB of image; the backend refuses > 400 KB). */
+export declare const MAX_SCREENSHOT_LENGTH = 500000;
+/** Library load + render must finish within this or the event is sent without it. */
+export declare const SCREENSHOT_TIMEOUT_MS = 3000;
+/** At most one screenshot per interval to protect the host app's main thread. */
+export declare const SCREENSHOT_MIN_INTERVAL_MS = 10000;
+export declare const SCREENSHOT_MAX_SCALE = 1;
+/** Screenshots are downscaled so they are at most this many pixels wide. */
+export declare const SCREENSHOT_MAX_WIDTH = 1280;
+export declare const MASK_COLOR = "#000000";
+/** Always masked, in addition to config.maskSelectors. */
+export declare const DEFAULT_MASK_SELECTORS: readonly string[];

package/dist/types/core/circularBuffer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Fixed-capacity FIFO buffer. Once full, each push overwrites the oldest item.
+ */
+export declare class CircularBuffer<T> {
+    private readonly capacity;
+    private readonly items;
+    private start;
+    private count;
+    constructor(capacity: number);
+    push(item: T): void;
+    /** Items from oldest to newest. */
+    toArray(): T[];
+    get size(): number;
+    clear(): void;
+}