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

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

@@ -0,0 +1,71 @@
+import { CapturedError, CollectorSink, PerformanceIssueKind } from '../collectors/collector';
+import { MemoryReading } from '../collectors/memoryCollector';
+import { ScreenshotCollector } from '../collectors/screenshotCollector';
+import { Transport } from '../transport/httpTransport';
+import { OfflineStore } from '../transport/offlineStore';
+import { BreadcrumbInput, EventLevel, TrackedUser } from '../types';
+import { ResolvedConfig } from './config';
+import { Deduplicator, RateLimiter } from './eventFilters';
+import { Logger } from './logger';
+/** Dependency overrides, used by tests. */
+export interface ClientDependencies {
+    transport?: Transport;
+    store?: OfflineStore;
+    random?: () => number;
+    rateLimiter?: RateLimiter;
+    deduplicator?: Deduplicator;
+    readMemory?: () => MemoryReading | null;
+    screenshot?: ScreenshotCollector;
+    queueRetryDelaysMs?: readonly number[];
+    queueFlushDelayMs?: number;
+}
+/**
+ * Owns all SDK state for one `init()` call: configuration, collectors,
+ * scope (user, breadcrumbs) and the delivery queue.
+ */
+export declare class Client implements CollectorSink {
+    readonly logger: Logger;
+    private readonly config;
+    private readonly breadcrumbs;
+    private readonly device;
+    private readonly queue;
+    private readonly random;
+    private readonly rateLimiter;
+    private readonly deduplicator;
+    private readonly network;
+    private readonly performance;
+    private readonly memory;
+    private readonly responsiveness;
+    private readonly screenshot;
+    private readonly collectors;
+    private user;
+    private rateLimitWarned;
+    /** Events dropped by the rate limiter since the last summary event. */
+    private droppedCount;
+    private droppedTimer;
+    private started;
+    /** Events waiting on a screenshot before they can be queued. */
+    private pendingCaptures;
+    private readonly handleOnline;
+    private readonly handleVisibility;
+    private readonly handlePageHide;
+    constructor(config: ResolvedConfig, deps?: ClientDependencies);
+    /** Installs collectors and lifecycle listeners, then sends events left over from earlier sessions. */
+    start(): void;
+    /** Removes every hook from the page. Unsent events are persisted. */
+    close(): Promise<void>;
+    /** Waits for events still awaiting a screenshot, then sends everything queued. */
+    flush(): Promise<void>;
+    captureError(thrown: unknown, context?: object): void;
+    captureMessage(message: string, level: EventLevel): void;
+    setUser(user: TrackedUser | null): void;
+    onError(captured: CapturedError): void;
+    onBreadcrumb(input: BreadcrumbInput): void;
+    onPerformanceIssue(kind: PerformanceIssueKind, message: string): void;
+    onNavigation(): void;
+    private capture;
+    /** Counts a rate-limited event and schedules one summary event, so storms stay visible. */
+    private recordDropped;
+    private finish;
+    private scope;
+}

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

@@ -0,0 +1,28 @@
+import { ErrorTrackerConfig, TrackerEvent } from '../types';
+/** Config with defaults applied and values validated. */
+export interface ResolvedConfig {
+    apiKey: string;
+    endpoint: string;
+    environment: string;
+    appVersion: string | null;
+    sampleRate: number;
+    maxBreadcrumbs: number;
+    maskSelectors: string[];
+    debug: boolean;
+    captureHttpErrors: boolean;
+    captureNetworkErrors: boolean;
+    captureConsoleErrors: boolean;
+    captureScreenshots: boolean;
+    html2canvasUrl: string;
+    html2canvasIntegrity: string;
+    beforeSend: ((event: TrackerEvent) => TrackerEvent | null) | null;
+}
+export type ConfigResult = {
+    ok: true;
+    config: ResolvedConfig;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Validates user config and fills in defaults. Never throws. */
+export declare function resolveConfig(input: ErrorTrackerConfig | null | undefined): ConfigResult;

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

@@ -0,0 +1,23 @@
+import { DevicePayload } from '../types';
+/** Browser/OS identity parsed from a user-agent string. */
+export interface ParsedUserAgent {
+    browser: string | null;
+    browserVersion: string | null;
+    os: string | null;
+    osVersion: string | null;
+    model: string | null;
+}
+/** Pure user-agent parser; exported for testing. */
+export declare function parseUserAgent(ua: string): ParsedUserAgent;
+/**
+ * Collects static device information once, then refines the OS name
+ * asynchronously using UA Client Hints where the browser supports them.
+ */
+export declare class DeviceInfo {
+    private parsed;
+    constructor();
+    /** Best-effort async refinement (distinguishes Windows 11 from 10, adds Android model). */
+    refine(): Promise<void>;
+    /** Snapshot for a payload; URL and screen size are read fresh each time. */
+    snapshot(): DevicePayload;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Guarded access to browser globals so the SDK can be imported in Node.js,
+ * SSR and web workers without throwing.
+ */
+export declare function getWindow(): Window | null;
+export declare function getDocument(): Document | null;
+export declare function getNavigator(): Navigator | null;
+export declare function getPerformance(): Performance | null;
+/** localStorage throws on access in some privacy modes, so even reading the property is guarded. */
+export declare function getLocalStorage(): Storage | null;
+export declare function isOnline(): boolean;
+export declare function isPageVisible(): boolean;
+export declare function nowIso(): string;
+/** High-resolution monotonic time where available. */
+export declare function nowMs(): number;
+/** Removes the query string and fragment, which commonly carry tokens or PII. */
+export declare function stripQuery(url: string): string;
+/** Resolves relative URLs against the page so comparisons are reliable. */
+export declare function absoluteUrl(url: string): string;
+/** Rounds to whole milliseconds; negative or non-finite values become null. */
+export declare function toMs(value: number | null | undefined): number | null;

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

@@ -0,0 +1,32 @@
+import { ErrorPayload, StackFrame } from '../types';
+type Clock = () => number;
+/**
+ * Sliding-window rate limiter that protects the host app and the backend
+ * from error storms (e.g. an exception thrown inside an animation frame).
+ */
+export declare class RateLimiter {
+    private readonly maxEvents;
+    private readonly windowMs;
+    private readonly clock;
+    private timestamps;
+    constructor(maxEvents?: number, windowMs?: number, clock?: Clock);
+    /** Returns true and records the event if it fits within the limit. */
+    tryAcquire(): boolean;
+}
+/**
+ * Drops events whose fingerprint was already seen within the dedup window,
+ * so a loop throwing the same error does not send hundreds of copies.
+ */
+export declare class Deduplicator {
+    private readonly windowMs;
+    private readonly maxEntries;
+    private readonly clock;
+    private seen;
+    private order;
+    constructor(windowMs?: number, maxEntries?: number, clock?: Clock);
+    /** Returns true if this fingerprint is new (or its previous sighting has expired). */
+    isNew(fingerprint: string): boolean;
+}
+/** Fingerprint used for dedup: event type + error identity + top stack frame. */
+export declare function fingerprint(eventType: string, error: ErrorPayload | null, stacktrace: StackFrame[]): string;
+export {};

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

@@ -0,0 +1,60 @@
+import { TrackerEvent } from '../types';
+import { OfflineStore } from '../transport/offlineStore';
+import { Transport } from '../transport/httpTransport';
+import { Logger } from './logger';
+import { Scheduler } from './retryManager';
+export interface EventQueueOptions {
+    transport: Transport;
+    store: OfflineStore;
+    logger: Logger;
+    batchSize?: number;
+    /** Max serialized bytes per request; defaults to MAX_BATCH_BYTES. */
+    maxBatchBytes?: number;
+    flushDelayMs?: number;
+    retryDelaysMs?: readonly number[];
+    /** Injectable for tests; defaults to setTimeout. */
+    schedule?: Scheduler;
+    /** Injectable for tests; defaults to navigator.onLine. */
+    isOnline?: () => boolean;
+}
+/**
+ * In-memory event queue. Sends batches with retry, and falls back to the
+ * offline store when the device is offline or delivery keeps failing.
+ */
+export declare class EventQueue {
+    private queue;
+    private flushTimer;
+    private inFlight;
+    private closed;
+    private readonly transport;
+    private readonly store;
+    private readonly logger;
+    private readonly batchSize;
+    private readonly maxBatchBytes;
+    private readonly flushDelayMs;
+    private readonly retryDelaysMs;
+    private readonly schedule;
+    private readonly online;
+    constructor(options: EventQueueOptions);
+    /** Number of events waiting in memory (not counting the batch in flight). */
+    get size(): number;
+    /** Adds an event and schedules delivery. */
+    enqueue(event: TrackerEvent): void;
+    /** Sends everything currently queued. Resolves when the queue is drained or parked offline. */
+    flush(): Promise<void>;
+    /** Moves events from the offline store back into the queue and sends them. */
+    restoreFromStore(): Promise<void>;
+    /** Writes queued (not in-flight) events to the offline store, e.g. when the page is hidden. */
+    persistPending(): void;
+    /** Stops accepting events. Pending events are persisted for the next session. */
+    close(): void;
+    private scheduleFlush;
+    private cancelTimer;
+    /**
+     * How many queued events fit in the next request: at most batchSize events
+     * and at most maxBatchBytes serialized (always at least one event).
+     */
+    private nextBatchLength;
+    /** Sends batch after batch until the queue is empty or delivery has to stop. */
+    private drain;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Debug-only logger. Produces no output unless `debug: true` was configured.
+ *
+ * Every line starts with LOG_PREFIX; the breadcrumb collector's console hook
+ * uses it to keep SDK diagnostics out of the breadcrumb trail.
+ */
+export declare const LOG_PREFIX = "[ErrorTracker]";
+export declare class Logger {
+    private enabled;
+    constructor(enabled: boolean);
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    info(message: string, ...details: unknown[]): void;
+    warn(message: string, ...details: unknown[]): void;
+    error(message: string, ...details: unknown[]): void;
+    private write;
+}
+/** Shared logger used before init() and by modules without a client reference. */
+export declare const sharedLogger: Logger;

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

@@ -0,0 +1,32 @@
+import { Breadcrumb, DevicePayload, ErrorPayload, EventLevel, EventType, JsonObject, MemoryPayload, PerformancePayload, StackFrame, TrackedUser, TrackerEvent } from '../types';
+/** What happened: the event-specific part of a payload. */
+export interface EventInput {
+    eventType: EventType;
+    level: EventLevel;
+    error: ErrorPayload | null;
+    stacktrace: StackFrame[];
+    context: JsonObject | null;
+}
+/** Ambient state captured at the moment of the event. */
+export interface EventScope {
+    apiKey: string;
+    environment: string;
+    appVersion: string | null;
+    user: TrackedUser | null;
+    breadcrumbs: Breadcrumb[];
+    performance: PerformancePayload;
+    memory: MemoryPayload;
+    device: DevicePayload;
+    screenshot: string | null;
+}
+/** Performance block with every field present and nothing measured. */
+export declare function emptyPerformance(): PerformancePayload;
+/** Memory block with every field present and nothing measured. */
+export declare function emptyMemory(): MemoryPayload;
+/**
+ * Assembles a schema-complete event. All arrays and nested objects are copied
+ * so later mutation of SDK state cannot alter an event already in the queue.
+ */
+export declare function buildEvent(input: EventInput, scope: EventScope, timestamp: string): TrackerEvent;
+/** Returns a shallow copy of `event` with one top-level field replaced. */
+export declare function withField<K extends keyof TrackerEvent>(event: TrackerEvent, key: K, value: TrackerEvent[K]): TrackerEvent;

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

@@ -0,0 +1,18 @@
+/**
+ * Remembers error objects the SDK has already turned into events, so a single
+ * failure is never reported twice. Example: a failed `fetch` is reported as a
+ * NetworkError, and the same TypeError may later reach `unhandledrejection`
+ * or `console.error`; those later sightings are skipped.
+ *
+ * Uses a WeakSet, so remembered errors are still garbage-collected normally.
+ */
+/** Marks `value` as reported. Primitives cannot be tracked and are ignored. */
+export declare function markReported(value: unknown): void;
+/** True if `value` was already turned into an event. */
+export declare function wasReported(value: unknown): boolean;
+/** Remembers a signature (e.g. message + file + line) as reported, for a short time. */
+export declare function markSignatureReported(signature: string, now?: number): void;
+/** True if the signature was reported within the last few seconds. */
+export declare function wasSignatureReported(signature: string, now?: number): boolean;
+/** Signature for an error that has only text and a location (no error object). */
+export declare function locationSignature(message: string, filename: string | null, lineno: number | null): string;

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

@@ -0,0 +1,18 @@
+/** Outcome of a single delivery attempt. */
+export interface AttemptResult {
+    ok: boolean;
+    /** Whether trying again could succeed (network error, 5xx, 408, 429). */
+    retryable: boolean;
+    status: number | null;
+}
+/** Final outcome after all attempts. */
+export interface RetryOutcome extends AttemptResult {
+    attempts: number;
+}
+export type Scheduler = (fn: () => void, delayMs: number) => void;
+/**
+ * Runs `attempt` until it succeeds, fails non-retryably, or the backoff
+ * schedule (1s, 2s, 4s by default) is exhausted. Never rejects: a rejected
+ * attempt is treated as a retryable network failure.
+ */
+export declare function retryWithBackoff(attempt: () => Promise<AttemptResult>, delaysMs?: readonly number[], schedule?: Scheduler): Promise<RetryOutcome>;

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

@@ -0,0 +1,10 @@
+import { Logger } from './logger';
+/**
+ * Runs `fn` and converts any exception into a debug warning plus `fallback`.
+ * This is the SDK's main guarantee that it never throws into the host app.
+ */
+export declare function safely<T>(logger: Logger, label: string, fn: () => T, fallback: T): T;
+/** `safely` for functions with no meaningful return value. */
+export declare function safelyRun(logger: Logger, label: string, fn: () => void): void;
+/** Wraps a callback so exceptions inside it are swallowed (with a debug log). */
+export declare function guard<A extends unknown[]>(logger: Logger, label: string, fn: (...args: A) => void): (...args: A) => void;

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

@@ -0,0 +1,13 @@
+import { JsonObject, JsonValue } from '../types';
+/** Shortens a string to `max` characters, marking that it was cut. */
+export declare function truncate(value: string, max: number): string;
+/**
+ * Converts an arbitrary value into JSON-safe data: circular references,
+ * functions, DOM nodes, errors and deep/wide structures are all handled so
+ * `JSON.stringify` on the result can never throw.
+ */
+export declare function normalize(value: unknown, depth?: number): JsonValue;
+/** `normalize` for values that must end up as a JSON object. */
+export declare function normalizeObject(value: unknown): JsonObject;
+/** Converts any thrown value into a readable message string. */
+export declare function describeValue(value: unknown): string;

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

@@ -0,0 +1,5 @@
+import { StackFrame } from '../types';
+/** Parses a raw stack string. Unrecognised lines are skipped. */
+export declare function parseStack(stack: string | undefined | null): StackFrame[];
+/** Extracts frames from any thrown value that carries a `stack` string. */
+export declare function parseStackFromError(error: unknown): StackFrame[];

package/dist/types/index.d.ts

@@ -0,0 +1,55 @@
+import { BreadcrumbInput, ErrorTrackerConfig, EventLevel, TrackedUser } from './types';
+/**
+ * Starts the SDK: validates config, installs collectors and begins delivering
+ * events. Calling it again while running is ignored; call `close()` first to
+ * re-initialize. An invalid config leaves the SDK disabled (and logs a warning
+ * when `debug` is true) rather than throwing.
+ */
+declare function init(config: ErrorTrackerConfig): void;
+/**
+ * Reports a caught error. `handled` is `true` on the resulting event.
+ * @param error The thrown value; non-Error values are converted to a message.
+ * @param context Extra JSON-serializable data attached as `context`.
+ */
+declare function captureError(error: unknown, context?: Record<string, unknown>): void;
+/**
+ * Reports a free-form message.
+ * @param message Text of the message.
+ * @param level Severity; defaults to `'info'`.
+ */
+declare function captureMessage(message: string, level?: EventLevel): void;
+/**
+ * Attaches a user to all subsequent events. Pass `null` to clear it (e.g. on logout).
+ */
+declare function setUser(user: TrackedUser | null): void;
+/**
+ * Records a custom breadcrumb in the trail attached to future events.
+ */
+declare function addBreadcrumb(breadcrumb: BreadcrumbInput): void;
+/**
+ * Sends queued events immediately. Resolves when the queue is drained or
+ * parked offline; never rejects. Resolves immediately before `init()`.
+ */
+declare function flush(): Promise<void>;
+/**
+ * Flushes, then removes every hook the SDK installed (global handlers, fetch/XHR,
+ * history, console). Unsent events are persisted for the next session.
+ */
+declare function close(): Promise<void>;
+/** Whether `init()` has completed successfully. */
+declare function isInitialized(): boolean;
+/** The SDK's public surface. */
+export declare const ErrorTracker: {
+    init: typeof init;
+    captureError: typeof captureError;
+    captureMessage: typeof captureMessage;
+    setUser: typeof setUser;
+    addBreadcrumb: typeof addBreadcrumb;
+    flush: typeof flush;
+    close: typeof close;
+    isInitialized: typeof isInitialized;
+    version: string;
+};
+export { init, captureError, captureMessage, setUser, addBreadcrumb, flush, close, isInitialized };
+export default ErrorTracker;
+export type { ApiCall, Breadcrumb, BreadcrumbInput, BreadcrumbType, DevicePayload, ErrorPayload, ErrorTrackerConfig, EventBatch, EventLevel, EventType, JsonObject, JsonValue, MemoryPayload, PerformancePayload, StackFrame, TrackedUser, TrackerEvent, UserPayload, } from './types';

package/dist/types/transport/httpTransport.d.ts

@@ -0,0 +1,24 @@
+import { Logger } from '../core/logger';
+import { AttemptResult } from '../core/retryManager';
+import { TrackerEvent } from '../types';
+/** Anything that can deliver a batch of events. */
+export interface Transport {
+    send(events: TrackerEvent[]): Promise<AttemptResult>;
+}
+type FetchFn = typeof fetch;
+/** Classifies an HTTP status into the retry decision used by the queue. */
+export declare function classifyStatus(status: number): AttemptResult;
+/**
+ * POSTs batches as JSON using `fetch`. The API key is applied here, at send
+ * time, so it never needs to be written to persistent storage.
+ */
+export declare class HttpTransport implements Transport {
+    private readonly endpoint;
+    private readonly apiKey;
+    private readonly logger;
+    private readonly fetchFn;
+    constructor(endpoint: string, apiKey: string, logger: Logger, fetchFn?: FetchFn);
+    send(events: TrackerEvent[]): Promise<AttemptResult>;
+    private serialize;
+}
+export {};

package/dist/types/transport/offlineStore.d.ts

@@ -0,0 +1,33 @@
+import { Logger } from '../core/logger';
+import { TrackerEvent } from '../types';
+/** Persistence for events that could not be delivered. */
+export interface OfflineStore {
+    append(events: TrackerEvent[]): void;
+    /** Returns every stored event and clears storage. */
+    takeAll(): TrackerEvent[];
+}
+/**
+ * Stores undelivered events in localStorage under `_et_queue`.
+ *
+ * The API key is blanked before writing (it is re-applied by the transport
+ * at send time), and storage failures — quota exceeded, disabled storage,
+ * corrupt data — are handled without ever throwing.
+ */
+export declare class LocalStorageStore implements OfflineStore {
+    private readonly logger;
+    private readonly maxEvents;
+    private readonly key;
+    constructor(logger: Logger, maxEvents?: number, key?: string);
+    append(events: TrackerEvent[]): void;
+    takeAll(): TrackerEvent[];
+    private read;
+    private write;
+}
+/** In-memory store for environments without localStorage, and for tests. */
+export declare class MemoryStore implements OfflineStore {
+    private readonly maxEvents;
+    private events;
+    constructor(maxEvents?: number);
+    append(events: TrackerEvent[]): void;
+    takeAll(): TrackerEvent[];
+}

package/dist/types/types.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Public and wire-format types.
+ *
+ * The `TrackerEvent` interface mirrors the shared payload schema used by the
+ * JS, iOS and Android SDKs. Every field is always present on the wire; values
+ * that are unavailable on the web platform are `null`, never omitted.
+ */
+/** JSON-safe value produced by the SDK's serializer. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type EventType = 'error' | 'message' | 'performance' | 'crash';
+export type EventLevel = 'info' | 'warning' | 'error';
+export type BreadcrumbType = 'navigation' | 'click' | 'api' | 'log' | 'lifecycle' | (string & {});
+/** Options accepted by `ErrorTracker.init()`. */
+export interface ErrorTrackerConfig {
+    /** Project API key. Kept in memory only and sent in the `X-API-Key` header. */
+    apiKey: string;
+    /** Ingestion URL, e.g. `https://api.yourcompany.com/v1/events`. */
+    endpoint: string;
+    /** Deployment environment such as `production`, `staging` or `development`. */
+    environment?: string;
+    /** Version of the host application. */
+    appVersion?: string;
+    /** Fraction of events to keep, 0.0–1.0. Defaults to 1.0. */
+    sampleRate?: number;
+    /** Size of the breadcrumb ring buffer. Defaults to 30. */
+    maxBreadcrumbs?: number;
+    /** CSS selectors whose elements are blacked out in screenshots and click breadcrumbs. */
+    maskSelectors?: string[];
+    /** Log SDK diagnostics to the console. Defaults to false. */
+    debug?: boolean;
+    /** Report fetch/XHR responses with a 4xx/5xx status as error events. Defaults to true. */
+    captureHttpErrors?: boolean;
+    /**
+     * Report fetch/XHR requests that got no response (offline, timeout, CORS,
+     * DNS/SSL failure) as NetworkError events. User-cancelled requests are
+     * never reported. Defaults to true.
+     */
+    captureNetworkErrors?: boolean;
+    /** Report every `console.error(...)` call as an error event. Defaults to false (libraries log a lot of noise). */
+    captureConsoleErrors?: boolean;
+    /** Attach a screenshot to error events. Defaults to true. */
+    captureScreenshots?: boolean;
+    /** Override where html2canvas is loaded from (self-hosting is recommended). */
+    html2canvasUrl?: string;
+    /** SRI hash for `html2canvasUrl`. Set to an empty string to disable the integrity check. */
+    html2canvasIntegrity?: string;
+    /**
+     * Last chance to scrub or drop an event before it is queued.
+     * Return the (optionally modified) event, or `null` to drop it.
+     */
+    beforeSend?: (event: TrackerEvent) => TrackerEvent | null;
+}
+/** User attached to every subsequent event. */
+export interface TrackedUser {
+    id: string;
+    email?: string;
+    name?: string;
+}
+/** Breadcrumb supplied through `ErrorTracker.addBreadcrumb()`. */
+export interface BreadcrumbInput {
+    type: BreadcrumbType;
+    message: string;
+    data?: object;
+}
+export interface SdkInfo {
+    name: string;
+    version: string;
+}
+export interface UserPayload {
+    id: string | null;
+    email: string | null;
+    name: string | null;
+}
+export interface ErrorPayload {
+    message: string;
+    type: string;
+    handled: boolean;
+}
+export interface StackFrame {
+    filename: string | null;
+    lineno: number | null;
+    colno: number | null;
+    function: string;
+}
+export interface Breadcrumb {
+    timestamp: string;
+    type: BreadcrumbType;
+    message: string;
+    data: JsonObject;
+}
+export interface ApiCall {
+    url: string;
+    method: string;
+    /** HTTP status; 0 when the request failed before a response arrived. */
+    status: number;
+    duration_ms: number;
+}
+export interface PerformancePayload {
+    page_load_ms: number | null;
+    ttfb_ms: number | null;
+    fcp_ms: number | null;
+    lcp_ms: number | null;
+    /** Cumulative Layout Shift score (unitless). JS-only extension of the shared schema. */
+    cls: number | null;
+    startup_ms: number | null;
+    frame_rate_fps: number | null;
+    slow_screen: boolean;
+    api_calls: ApiCall[];
+    slow_api_calls: ApiCall[];
+}
+export interface MemoryPayload {
+    used_mb: number | null;
+    total_mb: number | null;
+    leak_suspected: boolean | null;
+    oom_kill: boolean | null;
+}
+export interface DevicePayload {
+    platform: string;
+    os: string | null;
+    os_version: string | null;
+    manufacturer: string | null;
+    model: string | null;
+    browser: string | null;
+    browser_version: string | null;
+    screen_width: number | null;
+    screen_height: number | null;
+    url: string | null;
+    /** JS-only extension of the shared schema. */
+    referrer: string | null;
+    locale: string | null;
+}
+/** A single event as sent to the ingestion endpoint. */
+export interface TrackerEvent {
+    sdk: SdkInfo;
+    api_key: string;
+    event_type: EventType;
+    /** Severity. JS-only extension of the shared schema. */
+    level: EventLevel;
+    timestamp: string;
+    environment: string;
+    app_version: string | null;
+    user: UserPayload;
+    error: ErrorPayload | null;
+    stacktrace: StackFrame[];
+    breadcrumbs: Breadcrumb[];
+    screenshot: string | null;
+    performance: PerformancePayload;
+    memory: MemoryPayload;
+    device: DevicePayload;
+    /** Extra data passed to `captureError(error, context)`. JS-only extension. */
+    context: JsonObject | null;
+}
+/** Body of a batched POST to the endpoint. */
+export interface EventBatch {
+    events: TrackerEvent[];
+}