@groundcover/browser 1.0.9 → 2.0.0-rc.1

package/CHANGELOG.md

@@ -4,6 +4,51 @@ All notable changes to `@groundcover/browser` are documented here. This project
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html) and the
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) format.
 
+## [2.0.0-rc.1] — 2026-09-29
+
+Second release candidate of `2.0.0`. Network and exception shaping move into the core shared with
+`@groundcover/react-native`. The `/json/rum` envelope is unchanged; the changes below are the only
+differences on the wire.
+
+### Fixed
+
+- **`tracing.propagationUrls` treats only `*` as a wildcard.** Every other character kept its regex
+  meaning, so `https://api.example.com/*` also matched `https://api-example.com/…` and trace headers
+  (plus any `tracing.origin` header) were sent to lookalike hosts.
+- **A path pattern such as `"/api/*"` matches same-origin requests only, whether they are written as
+  relative or absolute URLs.** XHR requests opened with a relative URL were never matched (XHR stores
+  the resolved URL), and a protocol-relative `//other-host/api/…` was. Patterns are matched against
+  the URL the browser actually requests, so `https://app/api/../private` no longer matches
+  `https://app/api/*`.
+- **`fetch` events keep their trace ids when a configured header name has capitals.** `fetch` stores
+  request headers lowercased, so `traceIdHeaderName: "X-Trace-Id"` or
+  `propagationHeaders: ["X-Custom"]` never matched on read-back.
+- **A read-only `fetch` no longer costs the XHR capture** (and no longer throws out of
+  initialization); the two transports are instrumented independently.
+- **Navigation instrumentation wraps the history methods present at initialization**, keeping a
+  router that wrapped them after the SDK was constructed.
+
+### Changed
+
+- **`span_name` carries the upper-cased method**, like `operation.name`: `fetch(url, { method: "post" })`
+  is the span `POST /path`, not a separate `post /path`. A missing method reads `UNKNOWN`.
+- **An opaque host object passed without a key is labelled `opaque_node`** (was `dom_node`) by the
+  enricher's placeholder. Keyed placeholders are unchanged.
+
+## [2.0.0-rc.0] — 2026-09-28
+
+First release candidate of `2.0.0`. **Contains breaking changes from `1.x`** — see
+[Migrating from 1.x to 2.0.0](./README.md#migrating-from-1x-to-200).
+
+### Changed (breaking)
+
+- **Event-level sampling is removed.** `options.eventSampleRate` warns and is ignored, on `init` and
+  on `updateConfig`; use `options.sessionSampleRate` to select whole sessions. Rates are not
+  converted.
+- **`appId` is required and fixed per SDK instance.** It must be a non-blank string, its value is
+  preserved exactly, the first successful `init` wins (later calls are ignored; a failed init may be
+  retried), and `updateConfig` rejects any update that contains `appId`.
+
 ## [1.0.9]
 
 Stable release of `1.0.9-rc.0`. The shipped `dist/` is byte-for-byte the RC's — nothing landed after

package/README.md

@@ -32,6 +32,7 @@ for the full product guide.
 - [Session lifecycle](#session-lifecycle)
 - [Performance considerations](#performance-considerations)
 - [API reference](#api-reference)
+- [Migrating from 1.x to 2.0.0](#migrating-from-1x-to-200)
 - [Migrating to 1.0.0](#migrating-to-100)
 
 ---
@@ -80,6 +81,11 @@ groundcover.sendCustomEvent({ event: "plan_upgraded", attributes: { plan: "pro"
 `init()` takes connection/identity fields at the top level and all behavioral knobs under
 `options`, grouped by concern.
 
+The first successful `init()` initializes the SDK. Every later call is silently ignored, even with
+a different `appId` or config. Calls made during initialization are also ignored; if initialization
+fails, a later call can retry. Use [`updateConfig()`](#updating-config-at-runtime) or the other runtime
+APIs for supported changes.
+
 ```ts
 groundcover.init({
   // ── Connection & identity ──
@@ -89,7 +95,7 @@ groundcover.init({
 
   options: {
     debug,
-    sessionSampleRate, eventSampleRate,
+    sessionSampleRate,
     enabledEvents, excludedUrls,
     sessionMaxDuration,
     beforeSend, enrichEvent,
@@ -108,7 +114,7 @@ groundcover.init({
 | `apiKey` | `string` | ✅ | Your groundcover RUM API key. |
 | `dsn` | `string` | ✅ | RUM intake endpoint. A bare host is upgraded to `https://`. |
 | `cluster` | `string` | ✅ | Target groundcover cluster. |
-| `appId` | `string` | ✅ | Application identifier; reported as `service.name`. |
+| `appId` | `string` | ✅ | Required application identifier; cannot be empty or whitespace-only. Reported unchanged as `service.name`. |
 | `environment` | `string` | — | Deployment environment (e.g. `production`, `staging`). |
 | `namespace` | `string` | — | Logical grouping/namespace for the app. |
 | `releaseId` | `string` | — | Release/version identifier (e.g. a semver or commit hash). |
@@ -122,7 +128,6 @@ groundcover.init({
 |---|---|---|---|
 | `debug` | `boolean` | `false` | Verbose SDK console logging. |
 | `sessionSampleRate` | `number` | `1` | Fraction of sessions captured (0–1). |
-| `eventSampleRate` | `number` | `1` | Fraction of events captured (0–1). |
 | `enabledEvents` | `Array<…>` | `[]` | Instrumentations to enable. **Empty = all.** Members: `dom`, `network`, `exceptions`, `logs`, `pageload`, `navigation`, `performance`, `replay`. Note: `replay` still requires an explicit [`startReplayRecording()`](#session-replay) call — it never auto-starts. |
 | `excludedUrls` | `Array<string \| RegExp>` | — | Network requests matching these are not captured. |
 | `sessionMaxDuration` | `number` | `4h` | Target max session length in ms (1 min – 8 h). See [session lifecycle](#session-lifecycle). |
@@ -140,7 +145,7 @@ Distributed-tracing header propagation for outgoing requests.
 
 | Option | Type | Default | Description |
 |---|---|---|---|
-| `propagationUrls` | `string[]` | `[]` | Request URLs (prefix/`*`-glob match) that receive injected tracing headers. |
+| `propagationUrls` | `string[]` | `[]` | Request URLs that receive injected tracing headers. Each pattern must match the whole URL; only `*` is a wildcard. A path pattern such as `"/api/*"` matches same-origin requests only. |
 | `propagationHeaders` | `string[]` | `[]` | Header names to read/propagate onto traced requests. |
 | `traceIdHeaderName` | `string` | `""` | Header carrying the trace id. |
 | `spanIdHeaderName` | `string` | `""` | Header carrying the span id. |
@@ -181,7 +186,9 @@ content use [`privacy`](#privacy--data-masking).
 
 ### Updating config at runtime
 
-`updateConfig` mirrors the `init` shape; nested groups merge one level deep (and `tracing.origin` /
+`updateConfig` accepts these optional fields: `cluster`, `environment`, `namespace`, `releaseId`,
+`dsn`, `apiKey`, `options`, and `user`. `appId` cannot be updated. `sessionId` is not accepted;
+use the separate `setSessionId()` API. Nested groups merge one level deep (and `tracing.origin` /
 `privacy.replay` one level deeper), so a partial update preserves the other keys in the group:
 
 ```ts
@@ -423,14 +430,20 @@ every other guarantee here is stated for that case.
 
 ### Micro-frontend session synchronization
 
-Pass a shared `sessionId` so multiple frontends report under one session:
+Initialize the shared SDK once in the shell with a shared `sessionId` so the micro-frontends report
+under one session. Each micro-frontend uses that same SDK to capture events:
 
 ```ts
+// Shell
 const sharedSessionId = "session-12345";
-groundcover.init({ /* …app… */ apiKey, dsn, cluster, appId: "shell", sessionId: sharedSessionId });
-groundcover.init({ /* …mfe… */ apiKey, dsn, cluster, appId: "micro-frontend", sessionId: sharedSessionId });
+groundcover.init({ apiKey, dsn, cluster, appId: "your-app-id", sessionId: sharedSessionId });
+
+// Micro-frontend using the shared SDK
+groundcover.sendCustomEvent({ event: "checkout_opened", attributes: { cartId: "cart-123" } });
 ```
 
+If you need to explicitly rebind the shared SDK to another session, use `setSessionId()`.
+
 ---
 
 ## Performance considerations
@@ -438,7 +451,8 @@ groundcover.init({ /* …mfe… */ apiKey, dsn, cluster, appId: "micro-frontend"
 - **Batching & compression** — events are buffered (`transport.batchSize` / `transport.batchTimeout`) and
   gzipped (`transport.compression`) to minimize request count and payload size.
 - **Web Worker offload** — replay packing and gzip run off the main thread (see above).
-- **Sampling** — cap volume with `sessionSampleRate` / `eventSampleRate`.
+- **Sampling** — use `sessionSampleRate` to select whole sessions. Events within selected
+  sessions are not randomly sampled; enabled-event settings, filtering, and privacy controls still apply.
 - **Scope what you capture** — drop noisy endpoints with `excludedUrls`, and disable unused
   instrumentations via `enabledEvents`.
 - **Lazy session rotation** — no background timers; rotation work happens only on real activity.
@@ -453,7 +467,7 @@ All methods are available on the default export and on `window.groundcover`.
 
 | Method | Description |
 |---|---|
-| `init(config)` | Initialize the SDK and install instrumentation. |
+| `init(config)` | Initialize the SDK and install instrumentation once; calls after successful initialization are ignored. |
 | `identifyUser(user)` | Attach user identity to subsequent events. |
 | `sendCustomEvent({ event, attributes })` | Emit a custom business event. |
 | `captureException(error, metadata?)` | Capture a handled error with optional context. |
@@ -500,6 +514,68 @@ groundcover.captureException(new Error("Payment failed"), {
 
 ---
 
+## Migrating from 1.x to 2.0.0
+
+`2.0.0` removes event-level sampling and makes browser application identity fixed after the first
+successful initialization. These are breaking changes; review your initialization and runtime
+updates before upgrading:
+
+```bash
+npm install @groundcover/browser@2.0.0-rc.1
+```
+
+| Change | Migration |
+|---|---|
+| `options.eventSampleRate` is removed | Delete it from initialization and runtime updates. Choose `options.sessionSampleRate` explicitly if you need to limit capture volume. |
+| `appId` is required and cannot be blank | Supply a non-empty, non-whitespace string at initialization. Its value is preserved exactly. |
+| Each SDK instance initializes once | Initialize in your application's bootstrap code. Use runtime APIs instead of calling `init()` again. |
+| `appId` cannot be updated | Exclude it from `updateConfig()`, including when spreading an initialization config. Its presence rejects the entire update, even if its value is unchanged or `undefined`. |
+
+### Why event-level sampling was removed
+
+Randomly dropping individual events leaves gaps in user journeys and can distort funnel analysis.
+The SDK now uses `sessionSampleRate` to select sessions without randomly dropping individual events
+within them. Enabled-event settings, filtering, and privacy controls still apply; session replay
+still requires an explicit start.
+
+> **Volume warning:** If you previously set `eventSampleRate` below `1`, upgrading can increase event
+> volume. The removed option has no effect: passing it warns and strips it from stored configuration.
+> `sessionSampleRate` is not a rename or an equivalent numeric replacement: `0.1` selects roughly 10%
+> of sessions, rather than sampling 10% of events within sessions. Rates are never automatically
+> converted. If event sampling was left at its default of `1`, this removal does not increase capture
+> through sampling alone.
+
+For example, if you deliberately choose to capture 10% of sessions:
+
+```ts
+groundcover.init({
+  apiKey, dsn, cluster,
+  appId: "checkout",
+  options: { sessionSampleRate: 0.1 },
+});
+```
+
+### Initialize once; update supported fields explicitly
+
+Missing, non-string, or blank `appId` values produce a warning and leave the SDK uninitialized.
+After correcting the input, call `init()` again. A failed initialization also permits an explicit
+retry; calls during initialization or after success are silently ignored, regardless of `appId`.
+
+Do not spread your initialization config into a runtime update:
+
+```ts
+// Pass only the fields you intend to change, without appId.
+groundcover.updateConfig({ dsn: newDsn, apiKey: newApiKey, cluster: newCluster });
+groundcover.identifyUser({ id: "user-123" });
+await groundcover.setSessionId("shared-session-id");
+```
+
+An update containing `appId` warns and applies **none** of its fields. Use `identifyUser()` for user
+identity and `setSessionId()` for session identity; neither changes the application identity.
+For micro-frontends, initialize the shared SDK once in the shell and reuse it in each frontend.
+
+---
+
 ## Migrating to 1.0.0
 
 `1.0.0` restructures `options` by concern (a clean break from `0.x`) and removes the deprecated

package/dist/index.d.mts

@@ -1,19 +1,9 @@
 /**
- * The event kinds the browser SDK ships today. This is the DEFAULT vocabulary,
- * not the only permitted one — see `BaseEvent`.
+ * `TType` lets a platform name its own event kinds without editing core, and every core class
+ * flows it through. Defaults to `string`, because the set of NAMES is open — a platform that
+ * wants a closed union passes its own. Shared shapes stay shared; only the vocabulary is open.
  */
-type KnownEventType = "dom.event" | "exception" | "network" | "log" | "pageload" | "navigation" | "custom" | "performance" | "replay";
-/**
- * `TType` is what lets a platform package name its own event kinds without
- * editing core: React Native can pass `KnownEventType | "tap" | "screen_view"`
- * and every core class below flows it through. It defaults to
- * `KnownEventType`, so nothing that only deals in the shipped browser kinds
- * has to spell it out.
- *
- * Shared shapes are still shared — the point is that the set of names is open,
- * not that each platform reinvents the envelope.
- */
-type BaseEvent<TType extends string = KnownEventType> = {
+type BaseEvent<TType extends string = string> = {
     type: TType;
     timestamp?: number;
     end_timestamp?: number;
@@ -33,30 +23,6 @@ type UserIdentifiers = {
     organization: string;
     properties: Record<string, unknown>;
 };
-type DomEventAttributes = {
-    dom_event_type: string;
-    dom_event_coordinates: {
-        clientX: number;
-        clientY: number;
-    };
-    dom_event_target: {
-        tagName: string;
-        id: string;
-        className: string;
-        text: string;
-        role: string;
-        accessibleName: string;
-        ariaLabel: string;
-        title: string;
-        alt: string;
-        placeholder: string;
-        name: string;
-        inputType: string;
-        href: string;
-    };
-    dom_event_selector: string;
-    dom_event_key_code: string;
-};
 type NetworkEventAttributes = {
     type: "HTTP";
     resource_name: string;
@@ -119,31 +85,6 @@ type LogEventAttributes = {
     message: string;
     level: string;
 } & Record<string, unknown>;
-type PageLoadEventAttributes = {
-    page_url: string;
-    page_resources: {
-        count: number;
-        totalSize: number;
-        totalDuration: number;
-        byType: {
-            [key: string]: {
-                count: number;
-                size: number;
-                duration: number;
-            };
-        };
-    };
-    page_referrer: string;
-    page_load_time: number;
-};
-type NavigationEventAttributes = {
-    page_url: string;
-    from_url?: string;
-    metadata?: Record<string, unknown>;
-    duration_ms: number;
-    start_timestamp: number;
-    end_timestamp: number;
-};
 type UserDefinedEventAttributes = {
     custom_event_name: string;
     custom_event_attributes?: Record<string, unknown>;
@@ -154,44 +95,9 @@ type PerformanceEventAttributes = {
     performance_metric_id: string;
     performance_metric_navigation_type: string;
 };
-type ReplayEventAttributes = {
-    /**
-     * Groundcover session replay payload.
-     *
-     * NOTE: This key is intentionally prefixed to avoid collisions with customer attributes.
-     */
-    _gc_replay_data: {
-        events: string[];
-    };
-    /**
-     * Indicates this batch starts with a full DOM snapshot.
-     * Full snapshots are taken at regular intervals to allow seeking directly to any point.
-     * Queryable for filtering/indexing purposes.
-     */
-    replay_is_full_snapshot?: boolean;
-    /**
-     * Timestamp when the full snapshot was taken (if replay_is_full_snapshot is true).
-     */
-    replay_full_snapshot_timestamp?: number;
-};
 
-type Event$1<T extends string, A> = Omit<BaseEvent<T>, "attributes"> & {
-    type: T;
-    attributes: A;
-};
-type EventTypes$1 = {
-    "dom.event": Event$1<"dom.event", DomEventAttributes>;
-    exception: Event$1<"exception", ErrorEventAttributes>;
-    network: Event$1<"network", NetworkEventAttributes>;
-    log: Event$1<"log", LogEventAttributes>;
-    pageload: Event$1<"pageload", PageLoadEventAttributes>;
-    navigation: Event$1<"navigation", NavigationEventAttributes>;
-    custom: Event$1<"custom", UserDefinedEventAttributes>;
-    performance: Event$1<"performance", PerformanceEventAttributes>;
-    replay: Event$1<"replay", ReplayEventAttributes>;
-};
 type PrivacyLevel = "mask-sensitive" | "mask-all" | "allow";
-/** The non-replay event surface a redactor field belongs to. */
+/** The event surface a redactor field belongs to. */
 type RedactKind = "request-body" | "response-body" | "query" | "header" | "log" | "error";
 interface RedactField {
     /** Immediate key of the value; `""` for whole-string fields (log/error message). */
@@ -233,23 +139,19 @@ interface PrivacyOptions$1 {
     /** Extra case-insensitive key substrings treated as sensitive, merged with the built-in patterns. */
     sensitiveKeys?: string[];
     /**
-     * Per-field custom redaction hook for non-replay events. Called on each leaf
+     * Per-field custom redaction hook for captured events. Called on each leaf
      * value during the redaction walk with the original typed value; see
      * {@link Redactor}. For arbitrary whole-event changes use `enrichEvent`.
      */
     redact?: Redactor;
-    /**
-     * Session-recording masking — replay is a platform feature (rrweb on the
-     * browser), so its masking surface is typed by the platform package: the
-     * browser SDK narrows this to `{ maskTextFn?, maskInputFn? }` over
-     * HTMLElement (see the browser package's `config/types.ts`). Core never
-     * reads it — it is resolved platform-side at record() time.
-     */
-    replay?: unknown;
 }
 /** Distributed-tracing header propagation for outgoing network requests. */
 interface TracingOptions {
-    /** Request URLs (prefix match) that receive injected tracing headers. */
+    /**
+     * Request URLs that receive injected tracing headers: whole-URL matches where
+     * only `*` is a wildcard. Which strings a pattern is matched against is the
+     * platform's (the browser adds a same-origin request's path).
+     */
     propagationUrls?: string[];
     /** Inbound header names to read/propagate onto traced requests. */
     propagationHeaders?: string[];
@@ -269,25 +171,23 @@ interface TransportOptions {
     batchSize?: number;
     /** Max ms a batch waits before flushing regardless of size (default 10000). */
     batchTimeout?: number;
-    /** Gzip-compress outgoing batches; offloaded to the Web Worker when available (default true). */
+    /** Gzip-compress outgoing batches; offloaded to the platform's async encoder when it has one (default true). */
     compression?: boolean;
 }
-interface SDKOptions$1<TEvent extends BaseEvent<string> = EventTypes$1[keyof EventTypes$1]> {
+interface SDKOptions$1<TEvent extends BaseEvent<string> = BaseEvent<string>> {
     /**
      * Which signal listeners to enable, by name. Empty array = all. The NAMES
      * are platform-defined (each platform ships its own listener set) — the
-     * platform package narrows this to its literal union (see the browser
-     * package's `config/types.ts`).
+     * platform package narrows this to its literal union.
      */
     enabledEvents: string[];
-    eventSampleRate: number;
     sessionSampleRate: number;
     debug: boolean;
     excludedUrls?: Array<string | RegExp>;
-    beforeSend?: (event: TEvent) => boolean;
-    enrichEvent?: (event: TEvent) => TEvent;
+    beforeSend?(event: TEvent): boolean;
+    enrichEvent?(event: TEvent): TEvent;
     /**
-     * Unified privacy / data-masking config driving replay + non-replay masking.
+     * Unified privacy / data-masking config for every captured surface.
      * ON by default (`level: 'mask-sensitive'`); see {@link PrivacyOptions}.
      */
     privacy?: PrivacyOptions$1;
@@ -296,51 +196,16 @@ interface SDKOptions$1<TEvent extends BaseEvent<string> = EventTypes$1[keyof Eve
     /** Batching & delivery of outgoing events; see {@link TransportOptions}. */
     transport?: TransportOptions;
     /**
-     * Session-recording controls — a platform feature slot core never reads.
-     * The platform package types it (the browser SDK narrows this to its
-     * rrweb `ReplayOptions`; platforms without recording ignore it).
-     */
-    replay?: unknown;
-    /**
-     * Target maximum wall-clock duration of a session, in milliseconds.
-     *
-     * Enforced LAZILY, on activity — not by a background timer. Once the cap has
-     * elapsed, the next user/business event (click, navigation, log, custom,
-     * network, exception, …) flushes buffered events under the current session
-     * id, then mints a fresh session id and restarts replay recording if it was
-     * active.
-     *
-     * Because it is activity-gated, this is NOT a hard upper bound: a session
-     * only rotates when the next qualifying event arrives. An idle or
-     * backgrounded tab that produces no such events — including one that is only
-     * emitting session-replay heartbeats, which never trigger rotation on their
-     * own — keeps the same session id past the cap until activity resumes. This
-     * is deliberate: it avoids minting "phantom" sessions for dormant tabs. (An
-     * idle tab with replay on is ultimately bounded by the 30-minute user-idle
-     * pause — recording stops when no user presence is detected — not by this
-     * cap.)
+     * Target maximum wall-clock duration of a session, in ms. Enforced LAZILY on activity, so NOT
+     * a hard bound — an idle session keeps its id past the cap, which deliberately avoids minting
+     * phantom sessions. Also bounded by a 30-minute inactivity gap, counting raw input as
+     * presence so passive reading does not end a session.
      *
-     * Sessions are also bounded by a 30-minute inactivity gap, enforced the same
-     * lazy way: when a user-interaction event (click, navigation, pageload,
-     * custom — not background network/log/performance traffic) arrives after 30+
-     * minutes without one, the session rotates first and replay recording
-     * restarts for the returning user. Raw user input (scroll, pointer, key,
-     * touch) also counts as presence even when it produces no SDK event, so
-     * passive engagement — reading, watching — doesn't end the session. The
-     * same gap check runs at init, so a reload after a long break also starts a
-     * fresh session.
-     *
-     * The flush is best-effort and the rotation always proceeds — it does not
-     * wait for or depend on successful delivery, so if that network request
-     * fails the batch may be lost while the new session id still takes effect.
-     *
-     * Defaults to 4 hours when omitted; must be between 1 minute and 8 hours.
-     * Values outside that range or otherwise invalid fall back to the 4-hour
-     * default with a `console.warn`.
+     * Defaults to 4 hours; must be 1 minute to 8 hours, else falls back with a warning.
      */
     sessionMaxDuration?: number;
 }
-interface SDKConfigInput$1<TEvent extends BaseEvent<string> = EventTypes$1[keyof EventTypes$1]> {
+interface SDKConfigInput$1<TEvent extends BaseEvent<string> = BaseEvent<string>> {
     apiKey: string;
     cluster: string;
     environment: string;
@@ -353,6 +218,76 @@ interface SDKConfigInput$1<TEvent extends BaseEvent<string> = EventTypes$1[keyof
     sessionId?: string;
 }
 
+type DomEventAttributes = {
+    dom_event_type: string;
+    dom_event_coordinates: {
+        clientX: number;
+        clientY: number;
+    };
+    dom_event_target: {
+        tagName: string;
+        id: string;
+        className: string;
+        text: string;
+        role: string;
+        accessibleName: string;
+        ariaLabel: string;
+        title: string;
+        alt: string;
+        placeholder: string;
+        name: string;
+        inputType: string;
+        href: string;
+    };
+    dom_event_selector: string;
+    dom_event_key_code: string;
+};
+type PageLoadEventAttributes = {
+    page_url: string;
+    page_resources: {
+        count: number;
+        totalSize: number;
+        totalDuration: number;
+        byType: {
+            [key: string]: {
+                count: number;
+                size: number;
+                duration: number;
+            };
+        };
+    };
+    page_referrer: string;
+    page_load_time: number;
+};
+type NavigationEventAttributes = {
+    page_url: string;
+    from_url?: string;
+    metadata?: Record<string, unknown>;
+    duration_ms: number;
+    start_timestamp: number;
+    end_timestamp: number;
+};
+type ReplayEventAttributes = {
+    /**
+     * Groundcover session replay payload.
+     *
+     * NOTE: This key is intentionally prefixed to avoid collisions with customer attributes.
+     */
+    _gc_replay_data: {
+        events: string[];
+    };
+    /**
+     * Indicates this batch starts with a full DOM snapshot.
+     * Full snapshots are taken at regular intervals to allow seeking directly to any point.
+     * Queryable for filtering/indexing purposes.
+     */
+    replay_is_full_snapshot?: boolean;
+    /**
+     * Timestamp when the full snapshot was taken (if replay_is_full_snapshot is true).
+     */
+    replay_full_snapshot_timestamp?: number;
+};
+
 /**
  * The view an event was captured on. Browser-owned: core has no notion of a
  * "current view" — it merges whatever the platform's `enrichAttributes`
@@ -412,13 +347,13 @@ interface ReplayMaskingOptions {
     /** rrweb `maskInputFn` pass-through. */
     maskInputFn?: (text: string, el: HTMLElement) => string;
 }
-interface PrivacyOptions extends Omit<PrivacyOptions$1, "replay"> {
+interface PrivacyOptions extends PrivacyOptions$1 {
     /** CSS selectors whose text/inputs are always masked (replay + DOM), regardless of `level` except `'allow'`. */
     maskSelectors?: string[];
     /** Session-recording (rrweb replay) masking — the only place replay can be masked. */
     replay?: ReplayMaskingOptions;
 }
-interface SDKOptions extends Omit<SDKOptions$1, "privacy" | "replay" | "enabledEvents" | "beforeSend" | "enrichEvent"> {
+interface SDKOptions extends Omit<SDKOptions$1, "privacy" | "enabledEvents" | "beforeSend" | "enrichEvent"> {
     /**
      * Inspect each event before it is queued; return false to drop it. Typed
      * over the BROWSER event map, so `attributes.location` is visible here.
@@ -442,7 +377,7 @@ interface SDKOptions extends Omit<SDKOptions$1, "privacy" | "replay" | "enabledE
 interface SDKConfigInput extends Omit<SDKConfigInput$1, "options"> {
     options?: Partial<SDKOptions>;
 }
-type SDKConfigUpdate = Partial<Omit<SDKConfigInput, "sessionId" | "user">> & {
+type SDKConfigUpdate = Partial<Omit<SDKConfigInput, "appId" | "sessionId" | "user">> & {
     user?: SDKConfigInput["user"] | null;
 };
 
@@ -470,7 +405,6 @@ declare class SessionManager {
     setSessionId(newSessionId?: string): Promise<void>;
     startReplayRecording(): void;
     stopReplayRecording(): void;
-    handoffForReinit(): void;
     destroy(): void;
 }
 
@@ -491,11 +425,11 @@ declare global {
         groundcover?: typeof groundcover;
     }
 }
-declare function init(params?: {
+declare function init(params: {
     cluster?: string;
     environment?: string;
     namespace?: string;
-    appId?: string;
+    appId: string;
     releaseId?: string;
     user?: Partial<UserIdentifiers>;
     dsn?: string;