@ashokreddydev/react-performance-monitor 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @ashokreddydev/react-performance-monitor
+
+## 0.1.0
+
+### Minor Changes
+
+- 23aecb8: New package: React performance monitoring — React Profiler boundaries, fetch/XHR/Axios timing with p50/p95/p99,
+  Core Web Vitals (web-vitals), Redux Toolkit middleware, browser timings (navigation, resources, long tasks,
+  visibility, memory) and error capture, a lazy developer panel with optional ECharts charts, bounded batching with
+  sendBeacon/fetch delivery and retry, and a backend-independent transport (plus a Trackora adapter).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ashok Penamalli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,310 @@
-# Temporary Holding Version
+# react-performance-monitor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Performance monitoring for React apps. It measures:
+
+- **component render times**, with React's Profiler
+- **API latency**: fetch, XHR and Axios, with p50/p95/p99
+- **Core Web Vitals**: LCP, INP, CLS, FCP and TTFB
+- **Redux action timing**
+- **long tasks, navigation and resource timing**, plus memory where the browser supports it
+- **uncaught errors**
+
+It also includes a floating developer panel with charts. It sends data to **any backend**: you give it an HTTP
+endpoint or your own transport.
+
+- **Safe by default.** It never throws into your app, and memory and retries are bounded. A session that is not
+  sampled does no work at all, and production sends no per-render events unless you turn them on.
+- **Private by default.** It never reads headers, cookies, request or response bodies, Redux state or action payloads.
+  URLs become templates (`/users/:id`). Query values are removed unless you allow them, and free text is masked.
+- **No re-renders caused by the SDK.** The provider's context never changes. Only components that read live
+  metrics update, at most twice a second.
+
+> Status: 0.x — the API may still change in minor versions.
+
+## Contents
+
+[Install](#install) · [Quick start](#quick-start) · [Configuration](#configuration) · [Collectors](#collectors) ·
+[Developer panel](#developer-panel) · [Redux](#redux) · [Axios](#axios) · [Hooks](#hooks) · [Delivery](#delivery) ·
+[Privacy](#privacy) · [Performance overhead](#performance-overhead) · [Production checklist](#production-checklist) ·
+[Troubleshooting](#troubleshooting) · [Custom collectors](#custom-collectors)
+
+## Install
+
+```bash
+npm install @ashokreddydev/react-performance-monitor
+# optional, only for the charts in the developer panel:
+npm install echarts
+```
+
+You need React 18 or newer. `web-vitals` is installed with the package. Redux Toolkit, Axios, ECharts and
+React Scan are optional. Only their own entry points use them.
+
+| Import | What it adds |
+|---|---|
+| `@ashokreddydev/react-performance-monitor` | provider, monitor, built-in collectors, `<ProfiledBoundary>`, hooks, `<PerformanceButton>` |
+| `…/redux` | `createPerformanceMiddleware()` |
+| `…/axios` | `instrumentAxios(instance, monitor)` |
+| `…/charts` | ECharts charts for the panel (needs `echarts`) |
+| `…/trackora` | `trackoraTransport()` for a Trackora server |
+
+ESM and CommonJS builds ship with TypeScript declarations. The package works in JavaScript and TypeScript apps and
+is tree-shakeable (`sideEffects: false`).
+
+## Quick start
+
+```tsx
+import { PerformanceButton, PerformanceProvider, ProfiledBoundary } from '@ashokreddydev/react-performance-monitor';
+
+export function Root() {
+  return (
+    <PerformanceProvider
+      config={{
+        applicationId: 'my-app',
+        environment: import.meta.env.MODE,
+        sampleRate: 0.2, // 20 % of sessions send telemetry
+        collectors: { components: true, api: true, webVitals: true, browser: true, errors: true },
+        transport: { endpoint: '/api/performance/batch', batchSize: 20, flushInterval: 10_000 },
+      }}
+    >
+      <ProfiledBoundary id="App">
+        <App />
+      </ProfiledBoundary>
+      <PerformanceButton loadCharts={() => import('@ashokreddydev/react-performance-monitor/charts')} />
+    </PerformanceProvider>
+  );
+}
+```
+
+The provider reads `config` once, on the first render. To change it, remount the provider (for example with a new
+`key`). The API, Web Vitals, browser and error collectors start automatically, and each one can be switched off.
+
+## Configuration
+
+| Option | Default | Notes |
+|---|---|---|
+| `applicationId` | (required) | 1–64 letters, digits, `.`, `_`, `-` |
+| `environment` | `development` | Free text. `production` or `prod` turns off the dev-only defaults below. |
+| `release` | none | Your app version. Regressions are easier to tie to a deploy. |
+| `enabled` | `true` | Master switch. |
+| `sampleRate` | `1` | Share of sessions that send telemetry. Decided once per browser session. |
+| `collectors` | all on except `redux` | `{ components, api, webVitals, redux, browser, errors }` |
+| `thresholds` | renders 16 ms, API 1 000 ms, actions 16 ms, resources 1 000 ms, Google's Web Vitals | What counts as slow. |
+| `transport` | `false` (local only) | `{ endpoint, headers?, batchSize? (20, max 100), flushInterval? (10 s), maxRetries? (5) }`, or your own `Transport`. |
+| `maxBufferedEvents` | `500` (max 5 000) | Beyond this the oldest events are dropped, and the drop is counted and reported. |
+| `devtools` | on unless production | Collects locally for the panel even in unsampled sessions, and shows `<PerformanceButton>`. |
+| `components.recordRenders` | on unless production | In production only slow renders are sent. Every render is still aggregated. |
+| `redux.recordActions` | on unless production | In production only slow actions are sent. |
+| `api.ignoreUrls` | `[]` | URLs that are never measured. The SDK's own endpoint is always ignored. |
+| `api.allowedQueryParams` | `[]` | Query parameter names whose values are kept. |
+| `api.groupEndpoint` | none | Your own endpoint grouping, applied after the built-in templating. |
+| `beforeSend` | none | Change an event, or drop it with `null`, before it is queued. |
+| `debug` | `false` | `console.warn` for SDK problems, once per kind. |
+
+An invalid config never throws. The monitor disables itself and warns once.
+
+## Collectors
+
+Each collector is independent and has its own switch in `collectors`.
+
+| Collector | Measures | Notes |
+|---|---|---|
+| `components` | React Profiler `actualDuration`, `baseDuration`, mount or update, per `<ProfiledBoundary id>` / `withProfiler()` | React reports timings only in development and in the `react-dom/profiling` build. In a normal production build the boundary is free but silent. |
+| `api` | `fetch` and `XMLHttpRequest`: endpoint template, method, status, duration, success | It never reads headers or bodies. Its patches are removed on stop, but only if they are still the SDK's own. |
+| `webVitals` | LCP, INP, CLS, FCP, TTFB via `web-vitals` | Each metric is reported once per page view, when final. Its rating comes from your thresholds. Missing APIs are shown as "not supported". |
+| `redux` | Action type, dispatch time, whether state changed | Needs the `/redux` middleware. |
+| `browser` | Navigation timing, slow or failed resources, long tasks, visibility, JS heap | Long tasks are Chromium-only and memory is Chromium's `performance.memory`. Both are marked unsupported elsewhere. At most 100 resources and 200 long tasks are sent per page. |
+| `errors` | `error` and `unhandledrejection`: name, masked message, fingerprint | Stacks are not collected. Each error is sent at most 10× per page and then counted locally. Use an error tracker for full details. |
+
+**What counts as measured and what is inferred.** Render counts and durations come straight from React. The
+panel's "possibly unnecessary re-render" flag is a heuristic: many updates per mount, each costing close to a full
+render (actual ≈ base). It is labelled **inferred**. The SDK does not claim to detect every unnecessary re-render.
+Use React DevTools or React Scan to confirm.
+
+## Developer panel
+
+`<PerformanceButton>` puts a floating button in the bottom-right corner. It opens a responsive panel with eight tabs:
+Overview (warnings and recommendations), Components, Re-render analysis, API performance, Web Vitals, Redux, Browser
+and Errors.
+
+```tsx
+<PerformanceButton
+  theme="auto" // 'light' | 'dark' | 'auto'
+  themeOverrides={{ accent: '#7C3AED' }}
+  position="right"
+  loadCharts={() => import('@ashokreddydev/react-performance-monitor/charts')}
+  reactScan={scan} // optional: `import { scan } from 'react-scan'` adds an overlay toggle
+/>
+```
+
+- The panel code (about 6 KB gzip) is downloaded the first time the button is clicked.
+- Charts use Apache ECharts and load lazily. Large series are down-sampled (LTTB) and animation is switched off
+  above 500 points. Without `loadCharts` the panel shows simple built-in bars.
+- In production the button renders nothing (`devtools` is off) unless you pass `force`.
+- Accessibility: the panel is a labelled dialog, the tabs support arrow keys, Home and End, Escape closes the panel,
+  focus returns to the button, and no information is carried by colour alone.
+
+## Redux
+
+```ts
+import { configureStore } from '@reduxjs/toolkit';
+import { createPerformanceMiddleware } from '@ashokreddydev/react-performance-monitor/redux';
+
+export const store = configureStore({
+  reducer,
+  middleware: (getDefault) => getDefault().concat(createPerformanceMiddleware({ ignore: [/^ui\//] })),
+});
+```
+
+Set `collectors: { redux: true }`. By default the middleware reports to the running monitor. Pass
+`{ monitor }` to use a specific one, for example a `new PerformanceMonitor(config)` that you also give to
+`<PerformanceProvider monitor={monitor}>`. Thunks pass through untouched, and errors from reducers propagate
+unchanged.
+
+## Axios
+
+The global XHR patch already measures Axios' browser adapter. Use the Axios integration when you need Axios' own
+view instead: custom adapters, SSR, or `collectors.api` off. It claims each request, so nothing is counted twice.
+
+```ts
+import { instrumentAxios } from '@ashokreddydev/react-performance-monitor/axios';
+const stop = instrumentAxios(apiClient, monitor); // call stop() to remove the interceptors
+```
+
+## Hooks
+
+```tsx
+const monitor = usePerformance(); // stable; never re-renders
+monitor.setRoute('/orders/:id'); // call from your router on navigation
+monitor.record({ eventType: 'long_task', duration: 120, data: { source: 'self' } });
+
+const metrics = usePerformanceMetrics(); // live aggregates; re-renders at most every 500 ms
+const slowest = useApiPerformance('/api/orders'); // API stats, filtered by endpoint
+```
+
+Outside a provider the hooks return a disabled monitor, so shared components can call them safely.
+
+## Delivery
+
+- **When batches go out.** A batch is sent when it is full, every `flushInterval`, and when the page is hidden or
+  closed.
+- **Sending while the page closes.** Without custom headers the SDK uses `navigator.sendBeacon`. The body is sent
+  as `text/plain` to avoid a CORS preflight, so parse it as JSON. With headers it uses `fetch` with `keepalive`.
+  Cookies are never sent.
+- **Retries.** Retries use exponential backoff with jitter: 1 s, 2 s, 4 s and so on, up to 60 s, 5 attempts by
+  default.
+  - `4xx` responses are not retried.
+  - `Retry-After` is honoured.
+  - A request that hangs for 30 s counts as failed.
+- **Offline.** Nothing is sent while the browser is offline. Events wait in the bounded buffer.
+- **Dropped events.** Drops are never silent. Every batch carries `dropped: { overflow, failed, filtered }`.
+
+Each request body is one `PerformanceBatch`, with every event carrying its `eventType`, `timestamp`, `route`,
+`duration?`, `data` and `metadata?`:
+
+```json
+{
+  "schemaVersion": 1,
+  "applicationId": "my-app",
+  "environment": "production",
+  "release": "1.4.0",
+  "sessionId": "0f8fad5b-d9cb-469f-a165-70867728950e",
+  "sampleRate": 0.2,
+  "sentAt": 1794220000000,
+  "sdk": { "name": "react-performance-monitor", "version": "0.1.0" },
+  "dropped": { "overflow": 0, "failed": 0, "filtered": 0 },
+  "events": [
+    {
+      "eventType": "api_request",
+      "timestamp": 1794219999000,
+      "route": "/orders/:id",
+      "duration": 420,
+      "data": { "endpoint": "/api/orders/:id", "host": "", "method": "GET", "status": 200, "ok": true, "slow": false, "client": "fetch" }
+    }
+  ]
+}
+```
+
+On your server:
+- Authenticate the request with your own key or cookie.
+- Validate every field and cap the body at about 128 KB.
+- Take the application id from your authentication, not from the body.
+- Keep the data with a retention limit (TTL).
+
+## Privacy
+
+What it collects:
+- endpoint templates, methods, status codes and durations
+- component names that you choose
+- Redux action types
+- masked error messages and fingerprints
+- vitals and timings
+- a random session id
+
+It does not collect a user id. What it never collects:
+- request or response headers or bodies, or cookies
+- passwords
+- Redux state or payloads
+- stack traces
+- query values that are not allow-listed
+
+Sensitive-looking values (e-mails, card numbers, JWTs, phone numbers, government ids) are replaced with
+`[REDACTED]`, and so is `metadata` whose key names look sensitive.
+
+## Performance overhead
+
+| Measure | Value |
+|---|---|
+| `record()` per event (aggregation, sampling, buffer) | ~1–2 µs (measured over 50 000 events in CI) |
+| Unsampled production session | collectors are not started, no listeners, no timers |
+| Memory | buffer ≤ `maxBufferedEvents`, ≤ 100 keys per table plus `(other)`, 10-minute timeline, bounded quantile samples |
+| Bundle, main entry (minified + gzip) | ~15 KB, plus `web-vitals` ~2 KB |
+| Panel (lazy) / charts (lazy, excluding ECharts) | ~6 KB / ~2 KB |
+
+## Production checklist
+
+- Set `environment` from your build (`import.meta.env.MODE`). Production turns off `devtools`, `recordRenders` and
+  `recordActions`.
+- Pick a `sampleRate`, for example `0.1`–`0.3`.
+- Use an authenticated, rate-limited endpoint with a body limit and retention.
+- Wrap only the parts of the tree you care about in `<ProfiledBoundary>`. For production render timings, use the
+  `react-dom/profiling` build only if you need it.
+
+## Troubleshooting
+
+| Symptom | Cause and fix |
+|---|---|
+| No component data | React reports Profiler timings only in development or `react-dom/profiling`, and only inside `<ProfiledBoundary>`. |
+| A Web Vital stays "waiting…" | Vitals are final when the page is hidden. INP needs an interaction. LCP and INP are not supported in every browser. |
+| A metric shows "not supported" | The browser lacks the API (for example `longtask` or `memory` outside Chromium). The value is never shown as 0. |
+| Requests counted twice | You use `instrumentAxios` *and* a non-claiming wrapper. Use one, or set `collectors.api: false`. |
+| Nothing is sent | Check that the session is sampled (the panel chip says "sending" or "local only"), that `transport` is set, and run `debug: true`. |
+| Beacon requests fail on the server | Parse `text/plain` bodies as JSON. |
+
+## Custom collectors
+
+```ts
+import type { Collector } from '@ashokreddydev/react-performance-monitor';
+
+export const longTasks: Collector = {
+  name: 'browser',
+  start(ctx) {
+    if (typeof PerformanceObserver === 'undefined') {
+      ctx.markUnsupported('longtask');
+      return undefined;
+    }
+    const po = new PerformanceObserver((list) => {
+      for (const e of list.getEntries())
+        ctx.record({ eventType: 'long_task', duration: e.duration, data: { source: e.name } });
+    });
+    po.observe({ type: 'longtask', buffered: true });
+    return () => po.disconnect(); // always clean up
+  },
+};
+```
+
+Pass collectors with `<PerformanceProvider collectors={[longTasks]} builtInCollectors={false} />`. A collector that
+throws is contained, and reported when `debug` is on. It never stops the other collectors or your app.
+
+## License
+
+MIT

package/dist/PerformanceMonitor-BSWG4Ii-.d.cts

@@ -0,0 +1,183 @@
+import { C as CollectorName, T as Transport, H as HttpTransportOptions, P as PerformanceMonitorConfig } from './config-Cie78aAE.cjs';
+import { P as PerformanceThresholds, a as PerformanceEvent, f as PerformanceEventInput } from './performanceThresholds-B8-ZCvDG.cjs';
+import { M as MetricsSnapshot } from './metrics-LC7_GsyQ.cjs';
+
+/** Config after validation: every field present, every number inside its safe range. */
+interface ResolvedPerformanceConfig {
+    applicationId: string;
+    environment: string;
+    release: string | undefined;
+    enabled: boolean;
+    sampleRate: number;
+    collectors: Readonly<Record<CollectorName, boolean>>;
+    thresholds: PerformanceThresholds;
+    /** null = local only (no telemetry leaves the page). */
+    transport: Transport | HttpTransportOptions | null;
+    batchSize: number;
+    flushInterval: number;
+    maxRetries: number;
+    maxBufferedEvents: number;
+    devtools: boolean;
+    recordRenders: boolean;
+    recordActions: boolean;
+    api: {
+        ignoreUrls: readonly (string | RegExp)[];
+        allowedQueryParams: readonly string[];
+        groupEndpoint: ((endpoint: string) => string) | undefined;
+    };
+    beforeSend: ((event: PerformanceEvent) => PerformanceEvent | null) | undefined;
+    debug: boolean;
+}
+declare const COLLECTOR_NAMES: readonly CollectorName[];
+/** A problem found in the config. The monitor does not throw on bad config — it disables itself and warns once. */
+declare class PerformanceConfigError extends Error {
+    readonly name = "PerformanceConfigError";
+}
+/**
+ * Validates and fills defaults. Throws `PerformanceConfigError` only for things that cannot be defaulted
+ * (missing/invalid `applicationId`, invalid transport endpoint); `PerformanceMonitor` catches it and stays disabled.
+ */
+declare function resolveConfig(input: PerformanceMonitorConfig): ResolvedPerformanceConfig;
+
+declare const SDK_NAME = "react-performance-monitor";
+declare const SDK_VERSION: string;
+/** What a collector gets. Everything here is safe to call at any time — it never throws. */
+interface CollectorContext {
+    readonly config: ResolvedPerformanceConfig;
+    record(event: PerformanceEventInput, metadata?: Record<string, unknown>, options?: RecordOptions): void;
+    /** Current route template (e.g. `/orders/:id`). */
+    getRoute(): string;
+    /** true for the monitor's own telemetry requests and `api.ignoreUrls` — never measure these. */
+    isIgnoredUrl(url: string): boolean;
+    /** true when an integration (e.g. Axios) already measures this request — skip it. */
+    consumeClaim(method: string, url: string): boolean;
+    /** Tell the panel a browser API is missing (shown as "not supported", never as zero). */
+    markUnsupported(feature: string): void;
+    now(): number;
+    /** Report a problem inside the collector without breaking the host app. */
+    reportError(where: string, error: unknown): void;
+}
+interface RecordOptions {
+    /** Aggregate for the panel and hooks only; never sent (used for high-frequency, non-slow events). */
+    localOnly?: boolean;
+}
+/** The most recently started monitor — what `createPerformanceMiddleware()` uses when not given one. */
+declare function getActiveMonitor(): PerformanceMonitor | null;
+/** One independent measurement source. `start` returns its cleanup (observers, listeners, patches). */
+interface Collector {
+    readonly name: CollectorName;
+    start(ctx: CollectorContext): (() => void) | undefined;
+}
+interface PerformanceMonitorDeps {
+    /** Overrides the transport from the config (tests, custom delivery). */
+    transport?: Transport;
+    now?: () => number;
+    random?: () => number;
+    /** How often subscribers (panel, hooks) are told about new metrics. Default 500 ms. */
+    notifyIntervalMs?: number;
+    /** A send that takes longer counts as failed and is retried (a hanging request never blocks delivery). Default 30 s. */
+    sendTimeoutMs?: number;
+}
+/**
+ * The runtime: owns the config, session, sampling decision, collectors, buffer, aggregation and delivery.
+ * Rules: it never throws into the host app, holds a bounded amount of memory, and cleans up everything on `stop()`.
+ */
+declare class PerformanceMonitor {
+    /** null when the config was invalid — the monitor is then a no-op. */
+    readonly config: ResolvedPerformanceConfig | null;
+    /** `config`, or a disabled stand-in when it was invalid — so internals never deal with null. */
+    private readonly settings;
+    readonly sessionId: string;
+    /** This session sends telemetry (decided once per session from `sampleRate`). */
+    readonly sampled: boolean;
+    private readonly now;
+    private readonly random;
+    private readonly transport;
+    private readonly ownUrls;
+    private readonly buffer;
+    private readonly aggregate;
+    private readonly collectors;
+    private readonly cleanups;
+    private readonly listeners;
+    private readonly notify;
+    private readonly warned;
+    private readonly sendTimeoutMs;
+    private published;
+    private running;
+    private stopped;
+    private readonly claims;
+    private recordingDepth;
+    private route;
+    private pendingDropped;
+    private inflight;
+    private retry;
+    private retryTimer;
+    private flushTimer;
+    private soonTimer;
+    private detachWindow;
+    /** Internal problems so far (shown in the panel; never thrown). */
+    internalErrors: number;
+    constructor(config: PerformanceMonitorConfig, deps?: PerformanceMonitorDeps);
+    private transportOrThrow;
+    /** A monitor that does nothing — what hooks use outside a `<PerformanceProvider>`. */
+    static disabled(): PerformanceMonitor;
+    /** Telemetry leaves the page in this session. */
+    get sending(): boolean;
+    /** Collectors run: sending, or the developer panel needs local data. */
+    get collecting(): boolean;
+    get isRunning(): boolean;
+    /** The collector is switched on and this session collects (cheap check for hot paths, e.g. Redux, Profiler). */
+    isEnabled(name: CollectorName): boolean;
+    /**
+     * An integration that measures a request itself (e.g. Axios interceptors) claims it, so the global fetch/XHR
+     * patch skips the same request — no double counting. Claims expire after 60 s.
+     */
+    claimRequest(method: string, url: string): void;
+    /** true (and removes the claim) when an integration already measures this request. */
+    consumeClaim(method: string, url: string): boolean;
+    private absolute;
+    /** Register a collector (once per name). Skipped when switched off in `config.collectors`. */
+    use(collector: Collector): this;
+    start(): void;
+    /** Stops collectors, timers and listeners; sends what is buffered. Safe to call twice; `start()` works again. */
+    stop(): void;
+    /** The route attached to new events. Routers call this on navigation; default is the templated `location.pathname`. */
+    setRoute(route: string): void;
+    getRoute(): string;
+    /**
+     * Add one event. Never throws. Accepted from construction on (React Profiler callbacks fire before the provider's
+     * effect starts the monitor), ignored after `stop()` and when this session does not collect.
+     */
+    record(input: PerformanceEventInput, metadata?: Record<string, unknown>, options?: RecordOptions): void;
+    /** Per-render events are sent only when `recordRenders` is on; slow renders always are. */
+    private shouldSend;
+    private enqueue;
+    private countDropped;
+    private takeDropped;
+    private returnDropped;
+    private batch;
+    /**
+     * Sends buffered events. Normal flush: one batch at a time, failed batches retried with backoff.
+     * Unloading: everything left is handed to `sendBeacon`/`keepalive` at once, without waiting or retrying.
+     */
+    flush(options?: {
+        unloading?: boolean;
+    }): Promise<void>;
+    private deliver;
+    private flushUnloading;
+    private returnDroppedInto;
+    /** Stable function — pass straight to `useSyncExternalStore`. */
+    readonly subscribe: (listener: () => void) => (() => void);
+    /** Stable function; returns the same object until new metrics are published (at most every `notifyIntervalMs`). */
+    readonly getSnapshot: () => MetricsSnapshot;
+    /** Number of events waiting to be sent. */
+    get bufferedCount(): number;
+    private publish;
+    private context;
+    private startCollector;
+    isIgnoredUrl(url: string): boolean;
+    private reportError;
+    private warnOnce;
+}
+
+export { type Collector as C, PerformanceMonitor as P, type RecordOptions as R, SDK_NAME as S, COLLECTOR_NAMES as a, type CollectorContext as b, PerformanceConfigError as c, type PerformanceMonitorDeps as d, type ResolvedPerformanceConfig as e, SDK_VERSION as f, getActiveMonitor as g, resolveConfig as r };