diff --git a/.planning/codebase/ARCHITECTURE.md b/.planning/codebase/ARCHITECTURE.md
new file mode 100644
index 0000000000..4014b7341a
--- /dev/null
+++ b/.planning/codebase/ARCHITECTURE.md
@@ -0,0 +1,161 @@
+# Architecture
+
+**Analysis Date:** 2026-01-21
+
+## Pattern Overview
+
+**Overall:** Layered Event-Driven Architecture with Domain-Driven Design
+
+**Key Characteristics:**
+- Observable-based event system using pub/sub pattern (LifeCycle)
+- Clear dependency layering: core → rum-core → rum/logs/rum-react
+- Assembly pattern for event enrichment and transformation
+- Modular domain-driven structure with collection modules per concern
+- Batch-based transport with compression support
+
+## Layers
+
+**Core Layer:**
+- Purpose: Foundation library providing shared utilities and primitives
+- Location: `packages/core/src`
+- Contains: Browser APIs, observables, transport, session management, configuration, error handling, telemetry
+- Depends on: None (base layer)
+- Used by: All other packages (rum-core, logs, rum-react, worker, flagging)
+
+**RUM Core Layer:**
+- Purpose: Real User Monitoring business logic without UI-specific features
+- Location: `packages/rum-core/src`
+- Contains: Event collection (views, actions, errors, resources, long tasks, vitals), RUM assembly, contexts, tracing
+- Depends on: @datadog/browser-core
+- Used by: rum, rum-slim, rum-react packages
+
+**Product Layer:**
+- Purpose: User-facing SDK packages with specific feature sets
+- Location: `packages/rum`, `packages/rum-slim`, `packages/logs`, `packages/rum-react`
+- Contains: Public APIs, entry points, product-specific features (session replay, profiling, React integration)
+- Depends on: core and/or rum-core
+- Used by: End-user applications
+
+**Transport Layer:**
+- Purpose: Data transmission to Datadog backend
+- Location: `packages/core/src/transport`, `packages/rum-core/src/transport`
+- Contains: Batching, compression, HTTP requests, event bridge, flush control
+- Depends on: Core utilities
+- Used by: Collection modules
+
+**Browser Integration Layer:**
+- Purpose: Browser API observation and instrumentation
+- Location: `packages/core/src/browser`, `packages/rum-core/src/browser`
+- Contains: XHR/Fetch observables, performance observables, DOM mutation tracking, location change tracking
+- Depends on: Core utilities
+- Used by: Collection modules
+
+## Data Flow
+
+**RUM Event Collection Flow:**
+
+1. Browser event occurs (click, XHR, error, etc.)
+2. Observable captures raw event (xhrObservable, performanceObservable, etc.)
+3. Collection module processes event (actionCollection, resourceCollection, errorCollection)
+4. Collection emits RAW_RUM_EVENT_COLLECTED to LifeCycle with domain context
+5. Assembly module enriches event with contexts (view, session, user, global)
+6. Assembly emits RUM_EVENT_COLLECTED with fully assembled event
+7. Batch collects events and manages buffer
+8. FlushController triggers flush based on size/time/page exit
+9. Encoder compresses batch (optional, via worker)
+10. HttpRequest sends to Datadog intake
+
+**Context Enrichment:**
+
+1. Context managers maintain state (viewHistory, sessionContext, userContext, globalContext)
+2. Assembly reads current context values at event time
+3. Hooks allow custom transformation via beforeSend callbacks
+4. Rate limiters and telemetry track event volumes
+
+**State Management:**
+- Session state persisted in cookies/localStorage
+- View history maintained in memory with expiration
+- Context managers use Observable pattern for updates
+- ValueHistory tracks time-based context changes
+
+## Key Abstractions
+
+**LifeCycle:**
+- Purpose: Central event bus for SDK-internal communication
+- Examples: `packages/rum-core/src/domain/lifeCycle.ts`
+- Pattern: Type-safe pub/sub with enum-based event types (AUTO_ACTION_COMPLETED, RAW_RUM_EVENT_COLLECTED, RUM_EVENT_COLLECTED, etc.)
+
+**Observable:**
+- Purpose: Reactive data streams for browser events
+- Examples: `packages/core/src/tools/observable.ts`, `packages/core/src/browser/xhrObservable.ts`, `packages/core/src/browser/fetchObservable.ts`
+- Pattern: Subscribe/unsubscribe with typed callbacks, buffering support
+
+**Collection Modules:**
+- Purpose: Domain-specific event capture and processing
+- Examples: `packages/rum-core/src/domain/action/actionCollection.ts`, `packages/rum-core/src/domain/resource/resourceCollection.ts`, `packages/rum-core/src/domain/error/errorCollection.ts`
+- Pattern: Subscribe to observables, emit to LifeCycle, manage domain state
+
+**Assembly:**
+- Purpose: Event enrichment and transformation pipeline
+- Examples: `packages/rum-core/src/domain/assembly.ts`
+- Pattern: Combine raw events with contexts, apply hooks, validate modifications, emit assembled events
+
+**Context Managers:**
+- Purpose: Stateful context tracking with customer data
+- Examples: `packages/core/src/domain/contexts/userContext.ts`, `packages/rum-core/src/domain/contexts/viewHistory.ts`
+- Pattern: ContextManager interface with set/get/remove, validation, storage sync
+
+**Batch:**
+- Purpose: Event buffering and transmission
+- Examples: `packages/core/src/transport/batch.ts`
+- Pattern: Add messages to buffer, upsert by key, flush on trigger, encode before send
+
+## Entry Points
+
+**RUM Full (with Session Replay):**
+- Location: `packages/rum/src/entries/main.ts`
+- Triggers: Application calls `datadogRum.init()`
+- Responsibilities: Initialize RUM core, start recorder API, start profiler API, create deflate encoder, expose DD_RUM global
+
+**RUM Slim (without Session Replay):**
+- Location: `packages/rum-slim/src/entries/main.ts`
+- Triggers: Application calls `datadogRum.init()`
+- Responsibilities: Initialize RUM core with stub recorder, lighter bundle size
+
+**RUM Core Bootstrap:**
+- Location: `packages/rum-core/src/boot/startRum.ts`
+- Triggers: Called by product packages (rum, rum-slim)
+- Responsibilities: Start all collection modules, initialize contexts, start transport, wire up LifeCycle subscriptions
+
+**Logs:**
+- Location: `packages/logs/src/entries/main.ts`
+- Triggers: Application calls `datadogLogs.init()`
+- Responsibilities: Initialize log collection, start transport, expose DD_LOGS global
+
+**React Plugin:**
+- Location: `packages/rum-react/src/entries/main.ts`
+- Triggers: Application passes plugin to `datadogRum.init()`
+- Responsibilities: React error boundary, performance tracking, React Router integration
+
+## Error Handling
+
+**Strategy:** Monitored execution with fallback to ensure SDK never breaks host application
+
+**Patterns:**
+- `monitor()` and `monitored()` decorators wrap SDK functions to catch and report internal errors
+- `catchUserErrors()` wraps user-provided callbacks to isolate user code failures
+- `trackRuntimeError()` reports SDK errors to telemetry without throwing
+- `computeRawError()` normalizes error objects with stack traces
+- Multiple error sources tracked: console.error, window.onerror, unhandledrejection, CSP violations, ReportingObserver
+
+## Cross-Cutting Concerns
+
+**Logging:** Console display utilities with debug mode, warning/error helpers in `packages/core/src/tools/display.ts`
+
+**Validation:** Type checking and sanitization in context managers, JSON schema validation for remote config, field modification limits in assembly
+
+**Authentication:** Customer API keys in configuration, session tokens in cookies, synthetics test detection, tracking consent state management
+
+---
+
+*Architecture analysis: 2026-01-21*
diff --git a/.planning/codebase/CONCERNS.md b/.planning/codebase/CONCERNS.md
new file mode 100644
index 0000000000..579d94c8ad
--- /dev/null
+++ b/.planning/codebase/CONCERNS.md
@@ -0,0 +1,269 @@
+# Codebase Concerns
+
+**Analysis Date:** 2026-02-16
+
+## Tech Debt
+
+**Next-Major Deferred Cleanup (10 items):**
+- Issue: Ten `TODO next major` or `TODO(next-major)` comments defer breaking changes to the next major version. These accumulate complexity and make each option harder to remove.
+- Files:
+  - `packages/rum-core/src/domain/configuration/configuration.ts:186` - `enablePrivacyForActionName` should become the default
+  - `packages/rum-core/src/boot/preStartRum.ts:68` - Remove `globalContextManager`, `userContextManager`, `accountContextManager` from pre-start strategy
+  - `packages/rum-core/src/boot/rumPublicApi.ts:614` - Remove `strategy` from plugin `onRumStart` callback
+  - `packages/rum-core/src/boot/rumPublicApi.ts:724` - Decide on relative time support for `addTiming`
+  - `packages/rum-core/src/browser/performanceObservable.ts:241` - Remove performance entry fallback
+  - `packages/core/src/domain/configuration/configuration.ts:255` - Remove `internalAnalyticsSubdomain` option, replace with `proxyFn`
+  - `packages/core/src/browser/fetchObservable.ts:46` - Remove "WAIT" action when `trackEarlyRequests` is removed
+  - `packages/core/src/tools/readBytesFromStream.ts:6` - Always collect stream body when `trackEarlyRequests` is removed
+  - `packages/logs/src/boot/preStartLogs.ts:42` - Same context manager cleanup as rum-core
+  - `packages/rum-react/test/reactOldBrowsersSupport.ts:5` - Bump browser targets for `measureOptions`
+- Impact: Increasing configuration surface area with deprecated options that cannot be safely removed until the next major. Makes the init path harder to reason about.
+- Fix approach: Track all items in a v7 migration document. Group them for a single coordinated major version bump.
+
+**Generated Type Files Checked Into Source:**
+- Issue: Large auto-generated type files (2000+ lines) from JSON schemas committed to version control with `/* eslint-disable */`
+- Files: `packages/rum-core/src/rumEvent.types.ts` (2184 lines), `packages/core/src/domain/telemetry/telemetryEvent.types.ts` (942 lines), `packages/rum/src/types/sessionReplay.ts` (991 lines)
+- Impact: Massive diffs on schema changes, no linting on generated code, IDE performance degradation when these files are open
+- Fix approach: Generate at build time rather than checking in, or split schemas into smaller logical units
+
+**Flagging Package is a Stub:**
+- Issue: `packages/flagging` is a placeholder with zero implementation and a hardcoded `console.log`
+- Files: `packages/flagging/src/hello.ts` (entire file is a TODO), `packages/flagging/src/entries/main.ts`
+- Impact: Workspace overhead for a non-functional package. Dependency version (`@datadog/browser-core: 6.22.0`) is stale vs. the monorepo version (`6.27.1`), indicating it is not maintained alongside other packages.
+- Fix approach: Either implement the feature or remove the package from the workspace until it is ready
+
+**Old Cookie Migration Code:**
+- Issue: Migration code for legacy cookie format (`_dd`, `_dd_r`, `_dd_l`) permanently kept with comment: "This migration should remain in the codebase as long as older versions are available/live"
+- Files: `packages/core/src/domain/session/oldCookiesMigration.ts` (42 lines), called from `packages/core/src/domain/session/storeStrategies/sessionInCookie.ts`
+- Impact: Indefinite technical debt with no expiration date. Runs on every cookie-based session initialization.
+- Fix approach: Define a migration cutoff version (e.g., only support migrations from v5+). Add a `monitor-until` deadline.
+
+**Deprecated APIs Still Maintained:**
+- Issue: Multiple deprecated types and methods remain exported
+- Files:
+  - `packages/rum/src/entries/main.ts:35` - `RumGlobal` deprecated for `DatadogRum`
+  - `packages/rum-slim/src/entries/main.ts:24` - Same deprecation
+  - `packages/logs/src/entries/main.ts:29` - `LogsGlobal` deprecated for `DatadogLogs`
+  - `packages/core/src/tools/boundedBuffer.ts:6-19` - `BoundedBuffer` deprecated for `BufferedObservable`
+  - `packages/core/src/domain/configuration/configuration.ts:106` - `allowFallbackToLocalStorage` deprecated for `sessionPersistence: 'local-storage'`
+  - `packages/rum-core/src/boot/rumPublicApi.ts:280-283` - `setUser` without required `id` deprecated
+- Impact: Increases API surface, documentation burden, and test maintenance
+- Fix approach: Batch-remove all deprecated APIs in the v7 major release
+
+**Module-Level Mutable State (Global Singletons):**
+- Issue: At least 16 `let` declarations at module scope in `packages/core/src/` create shared mutable state
+- Files:
+  - `packages/core/src/tools/experimentalFeatures.ts:28` - `enabledExperimentalFeatures` singleton shared between RUM and Logs
+  - `packages/core/src/domain/telemetry/telemetry.ts:79` - `telemetryObservable` module-level variable
+  - `packages/core/src/tools/monitor.ts:3-4` - `onMonitorErrorCollected` and `debugMode` globals
+  - `packages/core/src/tools/valueHistory.ts:33-35` - `cleanupHistoriesInterval` and `cleanupTasks` globals
+  - `packages/core/src/tools/utils/timeUtils.ts:102` - `navigationStart` cache
+- Impact: Shared state between RUM and Logs products when used via NPM can cause unexpected cross-product side effects. Makes testing harder (requires explicit reset functions). Comment in `experimentalFeatures.ts` acknowledges: "an experimental flag set on the RUM product will be set on the Logs product."
+- Fix approach: Move shared state into an initialization context object passed through the call chain. Short-term: document all singletons and their cross-product implications.
+
+## Known Bugs
+
+**Session Replay Serialization Privacy Bugs (3 documented):**
+- Symptoms: Incorrect masking/unmasking behavior for certain form input types
+- Files: `packages/rum/src/domain/record/serialization/serializeAttributes.spec.ts`
+  - Line 101: `<img alt="value">` treated as `maskable-image` instead of `maskable` ("TODO: This is a bug!")
+  - Line 137: `<input type="color">` has inconsistent `maskUnlessAllowlisted` behavior ("TODO: This is almost certainly a bug")
+  - Line 173: `<input type="file">` falls back to DOM attribute value when `HTMLInputElement#value` is falsy ("TODO: This is a bug!")
+- Trigger: Elements with the above types are serialized for Session Replay under various privacy levels
+- Workaround: Tests document the incorrect behavior and treat it as expected for now
+
+**Firefox Worker Error Handling:**
+- Symptoms: Deflate worker errors handled differently across browsers
+- Files: `packages/rum/src/domain/deflate/deflateWorker.ts`
+- Trigger: Worker initialization failure - Chromium throws exception, Firefox fires error event
+- Workaround: Code handles both patterns. Comment references https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2
+
+**Session Replay Race Condition on Page Unload:**
+- Symptoms: Last segment may not be sent before page unload when using Web Worker
+- Files: `test/e2e/lib/framework/flushEvents.ts` (lines 10-23)
+- Trigger: Fast page navigation where Worker async communication completes after beforeunload event
+- Workaround: E2E tests use a delayed endpoint (`/ok?duration=200`) to allow Worker time to send requests
+
+**Privacy CSS Element Order Not Preserved:**
+- Symptoms: When ignoring `<script>`, `<link>`, or `<meta>` elements, CSS element order is not preserved in the replay
+- Files: `packages/rum-core/src/domain/privacy.ts:265`
+- Trigger: Pages with style elements interspersed with ignored elements
+- Workaround: None documented. Comment: "TODO: Preserve CSS element order, and record the presence of the tag, just don't render"
+
+## Security Considerations
+
+**Public API Accepts `any` Types:**
+- Risk: Several public API methods accept `any` for keys and values, bypassing TypeScript type checking at the integration boundary
+- Files: `packages/rum-core/src/boot/rumPublicApi.ts`
+  - Lines 246, 255: `setGlobalContextProperty(key: any, value: any)`, `removeGlobalContextProperty(key: any)`
+  - Lines 304, 313: `setUserProperty(key: any, property: any)`, `removeUserProperty(key: any)`
+  - Line 395: `addFeatureFlagEvaluation(key: string, value: any)`
+- Current mitigation: All values go through `sanitize()` before processing
+- Recommendations: Use `string` for keys and `unknown` for values to force explicit type narrowing
+
+**Internal APIs Exposed Without Isolation:**
+- Risk: Internal modules exported with only a JSDoc warning
+- Files: `packages/rum/src/entries/internal.ts`, `packages/rum/src/entries/internalSynthetics.ts`
+- Current mitigation: Warning comment states "not intended for public usages, and won't follow semver"
+- Recommendations: Use package entry points or `@internal` TypeScript annotations to make these harder to accidentally consume
+
+**Session Replay Data URL Size Limit:**
+- Risk: Temporarily bumped data URL attribute limit to 1MB
+- Files: `packages/rum/src/domain/record/serialization/serializeAttribute.ts:13`
+- Current mitigation: Comment: "TODO: temporarily bump the Session Replay limit to 1Mb for dataUrls. This limit should be removed after [PANA-2843] is implemented"
+- Recommendations: Track PANA-2843 completion and restore the original limit
+
+**Zone.js Workaround Uses `as any` Cast:**
+- Risk: `getZoneJsOriginalValue` accesses hidden properties via `(target as any)[Zone.__symbol__(name)]`
+- Files: `packages/core/src/tools/getZoneJsOriginalValue.ts:32`
+- Current mitigation: Function is well-documented and handles missing properties gracefully
+- Recommendations: Acceptable trade-off for Zone.js compatibility, but monitor for Zone.js API changes
+
+## Performance Bottlenecks
+
+**Recursive Privacy Level Computation:**
+- Problem: `getNodePrivacyLevel` recursively walks ancestor nodes to compute privacy level
+- Files: `packages/rum-core/src/domain/privacy.ts:21-38`
+- Cause: Each call traverses from the node to the root unless a cache is provided. Cache is per-mutation-batch, not persistent.
+- Improvement path: The optional `NodePrivacyLevelCache` mitigates this, but cache lifetime is limited to individual mutation batches. Consider a persistent cache invalidated on privacy attribute changes.
+
+**Request Registry Linear Scan:**
+- Problem: `getMatchingRequest` iterates over all buffered requests to find a match
+- Files: `packages/rum-core/src/domain/resource/requestRegistry.ts:30-45`
+- Cause: Linear scan with `MAX_REQUESTS = 1000` upper bound. For each performance resource entry, all buffered requests are checked.
+- Improvement path: Index requests by URL for O(1) lookup instead of O(n) scan
+
+**Sampler BigInt Fallback for Older Browsers:**
+- Problem: Browsers without BigInt support fall back to non-deterministic `performDraw` instead of consistent sampling
+- Files: `packages/rum-core/src/domain/sampler/sampler.ts:22-29`
+- Cause: BigInt required for Knuth factor sampling algorithm
+- Improvement path: Comment says "remove this when all browsers we support have BigInt support." Track browser support matrix and set a removal date.
+
+**Mutation Batching Timing Sensitivity:**
+- Problem: DOM mutation tracking batches mutations with requestIdleCallback but has strict timing constraints (16ms min, 100ms max)
+- Files: `packages/rum/src/domain/record/mutationBatch.ts`, `packages/rum/src/domain/record/trackers/trackMutation.ts` (420 lines)
+- Cause: Balance between UI responsiveness and data completeness for Session Replay
+- Improvement path: Monitor mutation processing time via telemetry. Consider adaptive batching for mutation-heavy SPAs.
+
+**View Keep-Alive Session Polling:**
+- Problem: Every 5 minutes per view, plus session store polling every 1 second
+- Files: `packages/rum-core/src/domain/view/trackViews.ts:89` (`SESSION_KEEP_ALIVE_INTERVAL`), `packages/core/src/domain/session/sessionStore.ts:40` (`STORAGE_POLL_DELAY`)
+- Cause: Keep session alive during user activity and detect cross-tab session changes
+- Improvement path: Current implementation is reasonable, but long-running SPAs with many views accumulate timers. The `KEEP_TRACKING_AFTER_VIEW_DELAY` (5 min) helps, but active views are never pruned.
+
+## Fragile Areas
+
+**Public API Orchestration (`rumPublicApi.ts`):**
+- Files: `packages/rum-core/src/boot/rumPublicApi.ts` (905 lines)
+- Why fragile: Central orchestration point. Manages pre-start buffering strategy that switches to post-start strategy via mutable `strategy` variable. Complex state machine with consent, initialization, manual view tracking, and remote configuration paths.
+- Safe modification: Follow existing `monitor()` or `callMonitored()` wrapping patterns for new methods. Test all initialization permutations (consent before/after init, manual views, Synthetics injection, event bridge).
+- Test coverage: `packages/rum-core/src/boot/rumPublicApi.spec.ts` (1027 lines)
+
+**Pre-Start Strategy Buffering:**
+- Files: `packages/rum-core/src/boot/preStartRum.ts` (332 lines)
+- Why fragile: Buffers all API calls before SDK initialization. Must maintain context managers, handle remote configuration fetch, and coordinate tracking consent. The `tryStartRum` function has multiple preconditions that must all be met.
+- Safe modification: New buffered methods must capture clock state at call time, not drain time. Always add `bufferApiCalls.add()` wrapping.
+- Test coverage: `packages/rum-core/src/boot/preStartRum.spec.ts` (873 lines)
+
+**Session Store Cross-Tab Synchronization:**
+- Files: `packages/core/src/domain/session/sessionStore.ts` (284 lines)
+- Why fragile: Polling-based cross-tab session synchronization with multiple state transitions (not-started, tracked, not-tracked, expired). Throttled expand/renew operations can race with expiration.
+- Safe modification: Always use `processSessionStoreOperations` for atomic read-modify-write. Never directly mutate session state.
+- Test coverage: `packages/core/src/domain/session/sessionStore.spec.ts` (731 lines)
+
+**DOM Mutation Tracking:**
+- Files: `packages/rum/src/domain/record/trackers/trackMutation.ts` (420 lines)
+- Why fragile: Topological sorting of mutations, shadow DOM traversal, privacy-level filtering, and node ID management. The `processChildListMutations` function has complex logic for detecting moved vs. added vs. removed nodes.
+- Safe modification: Test extensively with shadow DOM scenarios. Verify node ID assignment and cleanup. Check memory leaks for retained node references.
+- Test coverage: `packages/rum/src/domain/record/trackers/trackMutation.spec.ts` (1218 lines)
+
+**Action Name Extraction:**
+- Files: `packages/rum-core/src/domain/action/getActionNameFromElement.ts` (356 lines)
+- Why fragile: Multiple strategy layers (programmatic, priority, fallback) with DOM tree traversal up to 10 parent levels. Privacy-level interplay determines whether masking or extraction occurs. Experimental `USE_TREE_WALKER_FOR_ACTION_NAME` feature flag adds a parallel code path.
+- Safe modification: Test against diverse real-world HTML patterns. Keep strategy layers independent. The experimental tree walker should be fully tested before becoming default.
+- Test coverage: `packages/rum-core/src/domain/action/getActionNameFromElement.spec.ts` (1016 lines)
+
+## Scaling Limits
+
+**Event Size Limits:**
+- Current capacity: Single event max ~256KB, user data sanitized at 220KB
+- Limit: Large context objects or deeply nested structures hit size limits silently (truncated)
+- Scaling path: Document limits prominently. Consider telemetry for events hitting size boundaries.
+
+**Experimental Feature Flags (9 active):**
+- Current capacity: 9 flags in `packages/core/src/tools/experimentalFeatures.ts`
+- Limit: Combinatorial explosion of feature flag interactions makes testing all paths impractical
+- Scaling path: Establish lifecycle for experimental features: promote to default, remove, or expire. Currently no expiration mechanism.
+
+**Monitor-Until Telemetry Deadlines:**
+- Current items: 12 `monitor-until` comments, 5 set to "forever"
+- Files: `packages/core/src/domain/session/sessionManager.ts:195`, `packages/rum/src/boot/startRecording.ts:26`, `packages/logs/src/domain/reportError.ts:17`, `packages/rum-core/src/transport/formDataTransport.ts:35`, `packages/rum-core/src/domain/startCustomerDataTelemetry.ts:61`
+- Limit: "Forever" telemetry items never get cleaned up, accumulating telemetry processing overhead
+- Scaling path: Replace "forever" with concrete review dates. The time-bounded ones (2026-04-01, 2026-06-01, 2026-07-01) are well-managed.
+
+## Dependencies at Risk
+
+**Custom json-schema-to-typescript Fork:**
+- Risk: Using fork `bcaudan/json-schema-to-typescript#bcaudan/add-readonly-support` (referenced in root `package.json:77`)
+- Impact: All type definition files depend on this fork's code generation. If the fork is abandoned, schema type generation breaks.
+- Migration plan: Upstream the readonly support patch to the main `json-schema-to-typescript` project, or vendor the fork.
+
+**Karma Test Runner (v6):**
+- Risk: Karma has been deprecated (announced end-of-life). The project uses `karma: 6.4.4` with `jasmine-core: 3.99.1`.
+- Impact: No security patches or new features. Browser launcher compatibility may break with future browser versions.
+- Migration plan: Migrate to Vitest or Jest with browser-mode, or use Playwright for component testing. This is a significant effort given the 221 spec files.
+
+**Jasmine 3.x:**
+- Risk: Using `jasmine-core: 3.99.1` and `@types/jasmine: 3.10.19`. Jasmine 3.x is superseded by 5.x.
+- Impact: Missing modern features (async matchers, improved error messages). `@types/jasmine` 3.x may not cover newer patterns.
+- Migration plan: Upgrade Jasmine alongside or after Karma migration.
+
+## Missing Critical Features
+
+**No Automated Spec Coverage Enforcement:**
+- Problem: No tooling to ensure every source file has a corresponding `.spec.ts` file. Of ~301 non-type, non-index source files, many lack co-located specs. The `packages/flagging/` package has zero spec files.
+- Blocks: Regressions can be introduced in untested files without CI catching it
+- Priority: Medium - the project has good overall coverage in critical paths, but gaps exist in newer/peripheral code
+
+**No Error Boundary for React 18+ Concurrent Mode:**
+- Problem: React error boundary implementation uses class component pattern without concurrent mode testing
+- Files: `packages/rum-react/src/domain/error/errorBoundary.ts`
+- Blocks: Correct error tracking in applications using React concurrent features
+- Priority: Low - basic error boundary works; edge cases with Suspense are undocumented
+
+## Test Coverage Gaps
+
+**Flagging Package:**
+- What's not tested: Entire package has zero spec files
+- Files: `packages/flagging/src/hello.ts`, `packages/flagging/src/entries/main.ts`
+- Risk: Package is a stub, but if implementation begins without test infrastructure, regressions are likely
+- Priority: Low (stub), but becomes High when implementation begins
+
+**Session Replay Privacy Edge Cases:**
+- What's not tested: Multiple documented bugs in serialization tests are marked as known-incorrect behavior
+- Files: `packages/rum/src/domain/record/serialization/serializeAttributes.spec.ts` (lines 64-75, 101, 137, 173)
+- Risk: Privacy violations where data that should be masked is not masked (e.g., `<input type="file">` value leakage)
+- Priority: High - privacy bugs could expose user data in Session Replay
+
+**Click Chain Memory Management:**
+- What's not tested: Long-running SPA scenarios with rapid click accumulation
+- Files: `packages/rum-core/src/domain/action/trackClickActions.ts:98-102`
+- Risk: Comment documents a specific memory leak fix (clearing `currentClickChain` reference in finalize callback). Regression could re-introduce the leak.
+- Priority: Medium - manually verified but no long-running leak test
+
+**Remote Configuration + Local Config Combinations:**
+- What's not tested: Full matrix of remote configuration overrides interacting with local configuration values
+- Files: `packages/rum-core/src/domain/configuration/remoteConfiguration.ts` (302 lines)
+- Risk: `SUPPORTED_FIELDS` list (12 fields) creates a large interaction surface between remote and local config
+- Priority: High - can affect production monitoring behavior silently
+- Test coverage: `packages/rum-core/src/domain/configuration/remoteConfiguration.spec.ts` (712 lines) covers happy paths
+
+**Browser Extension:**
+- What's not tested: `developer-extension/` directory has no automated unit test coverage
+- Files: `developer-extension/src/` (background, content-scripts, devtools, panel)
+- Risk: Regressions in extension UI and DevTools integration go undetected
+- Priority: Low - developer tool, not customer-facing production code
+
+---
+
+*Concerns audit: 2026-02-16*
diff --git a/.planning/codebase/CONVENTIONS.md b/.planning/codebase/CONVENTIONS.md
new file mode 100644
index 0000000000..71af13b3ce
--- /dev/null
+++ b/.planning/codebase/CONVENTIONS.md
@@ -0,0 +1,654 @@
+# Coding Conventions
+
+**Analysis Date:** 2026-02-16
+
+## Naming Patterns
+
+**Files:**
+- Source files use **camelCase**: `sessionManager.ts`, `trackViews.ts`, `contextManager.ts`
+- Enforced by ESLint rule `unicorn/filename-case` with `camelCase` option
+- Scripts use **kebab-case**: `build-package.ts`, `check-typescript-compatibility.ts`
+- Type definition files use suffix `.types.ts`: `error.types.ts`, `browser.types.ts`, `deflate.types.ts`
+- Event type definition files use suffix `Event.types.ts`: `rawRumEvent.types.ts`, `rawTelemetryEvent.types.ts`
+- Spec files are co-located with implementation: `feature.ts` -> `feature.spec.ts`
+- Generic utility file names like `utils.ts` or `specHelper.ts` are **forbidden** (enforced by local ESLint rule `disallow-generic-utils`). Use domain-specific names instead: `timeUtils.ts`, `byteUtils.ts`, `stringUtils.ts`
+
+**Functions:**
+- Use **camelCase**: `createContextManager()`, `trackFirstContentfulPaint()`, `startSessionManager()`
+- Factory functions use `create` prefix: `createBatch()`, `createValueHistory()`, `createFlushController()`
+- Initialization functions use `start` prefix: `startSessionManager()`, `startTelemetry()`, `startErrorCollection()`
+- Tracking functions use `track` prefix: `trackViews()`, `trackRuntimeError()`, `trackEventCounts()`
+- Boolean-returning functions use `is`/`has`/`can` prefix: `isError()`, `isIntakeUrl()`, `canUseEventBridge()`
+
+**Variables:**
+- Use **camelCase**: `sessionStore`, `flushController`, `rawRumEvents`
+- Constants use **UPPER_SNAKE_CASE**: `SESSION_TIME_OUT_DELAY`, `FCP_MAXIMUM_DELAY`, `BUFFER_LIMIT`
+- Prefix unused parameters with `_`: `(_: any, __: string, descriptor: ...)`
+
+**Types:**
+- Interfaces and type aliases use **PascalCase**: `SessionManager`, `RawError`, `InitConfiguration`
+- Generic type parameters use single uppercase letters: `T`, `E`, `K`
+- Enum-like const objects use **PascalCase**: `ErrorSource`, `RumEventType`, `DefaultPrivacyLevel`
+
+## Enum Pattern (Critical Convention)
+
+**Never use plain TypeScript enums in production code.** Use `const enum` or the const-object-with-type pattern instead.
+
+**Preferred pattern - Const object with derived type (for public API types):**
+```typescript
+// In source:
+export const ErrorSource = {
+  AGENT: 'agent',
+  CONSOLE: 'console',
+  CUSTOM: 'custom',
+} as const
+
+export type ErrorSource = (typeof ErrorSource)[keyof typeof ErrorSource]
+```
+This avoids emitting extra JavaScript for enums and makes values available at runtime.
+
+**Const enum (for internal-only enums):**
+```typescript
+export const enum LifeCycleEventType {
+  VIEW_CREATED,
+  VIEW_UPDATED,
+  SESSION_EXPIRED,
+}
+```
+Use `const enum` when values are only used internally. Non-const enums are forbidden in production by ESLint rule `no-restricted-syntax`.
+
+**Entry points must not export enums** (enforced by `disallow-enum-exports` local rule for `packages/{rum,logs,flagging,rum-slim}/src/entries/*.ts`).
+
+**`isolatedModules` workaround:** When a `const enum` is used as interface keys, you must declare a companion `const` object with `declare`:
+```typescript
+// packages/rum-core/src/domain/lifeCycle.ts
+export const enum LifeCycleEventType {
+  VIEW_CREATED,
+  VIEW_UPDATED,
+}
+
+// Workaround for isolatedModules: true
+declare const LifeCycleEventTypeAsConst: {
+  VIEW_CREATED: LifeCycleEventType.VIEW_CREATED
+  VIEW_UPDATED: LifeCycleEventType.VIEW_UPDATED
+}
+
+export interface LifeCycleEventMap {
+  [LifeCycleEventTypeAsConst.VIEW_CREATED]: ViewCreatedEvent
+  [LifeCycleEventTypeAsConst.VIEW_UPDATED]: ViewEvent
+}
+```
+
+## Code Style
+
+**Formatting:**
+- Tool: **Prettier** 3.8.1
+- Config: `.prettierrc.yml`
+- Key settings:
+  - `printWidth: 120`
+  - `semi: false` (no semicolons)
+  - `singleQuote: true`
+  - `tabWidth: 2`
+  - `trailingComma: 'es5'`
+  - `arrowParens: 'always'`
+- Run: `yarn format`
+
+**Linting:**
+- Tool: **ESLint** 9 with flat config (`eslint.config.mjs`)
+- Plugins: `typescript-eslint`, `eslint-plugin-import`, `eslint-plugin-unicorn`, `eslint-plugin-jsdoc`, `eslint-plugin-jasmine`, and 13 custom local rules in `eslint-local-rules/`
+- Run: `yarn lint`
+- Key enforced rules:
+  - `camelcase` enforced (except `_dd_temp_` property)
+  - `curly` enforced (always use braces)
+  - `eqeqeq: 'smart'` (use `===` except for null checks)
+  - `no-bitwise` enforced
+  - `no-eval` enforced
+  - `object-shorthand` enforced
+  - `prefer-template` enforced (template literals over concatenation)
+  - `quotes: 'single'` with `avoidEscape`
+  - `no-console` enforced in production source files
+  - `arrow-body-style` enforced (use concise arrow bodies)
+  - `one-var: 'never'` (one declaration per line)
+  - `@typescript-eslint/no-explicit-any: 'off'` (any is allowed)
+  - `@typescript-eslint/consistent-type-imports: 'error'` (use `import type`)
+  - `@typescript-eslint/consistent-type-exports: 'error'`
+  - `@typescript-eslint/consistent-type-definitions: ['error', 'interface']` (prefer `interface` over `type` for object types)
+  - `@typescript-eslint/member-ordering` enforced (fields before constructors before methods, public before protected before private)
+  - `import/no-default-export: 'error'` (named exports only, except webpack configs)
+  - `import/no-cycle: 'error'`
+  - `jasmine/no-focused-tests: 'error'` (no `fdescribe`/`fit` committed)
+
+## Import Organization
+
+**Order (enforced by `import/order`):**
+1. Built-in modules (e.g., `node:path`)
+2. External packages (e.g., `@datadog/browser-core`)
+3. Internal (files from within a local package referenced by path alias, e.g., `@datadog/browser-core/test`)
+4. Parent directory imports (e.g., `../../tools/display`)
+5. Sibling imports (e.g., `./observable`)
+6. Index imports
+
+**Type imports must be separate (enforced by `@typescript-eslint/consistent-type-imports`):**
+```typescript
+// Correct:
+import type { Duration, RelativeTime } from '@datadog/browser-core'
+import { elapsed, relativeNow, ONE_MINUTE } from '@datadog/browser-core'
+
+// In production source files, prefer top-level type specifiers:
+import type { Configuration } from '../configuration'
+// Not: import { type Configuration } from '../configuration'
+```
+
+**Path Aliases (defined in `tsconfig.base.json`):**
+- `@datadog/browser-core` -> `packages/core/src`
+- `@datadog/browser-rum-core` -> `packages/rum-core/src`
+- `@datadog/browser-rum` -> `packages/rum/src/entries/main`
+- `@datadog/browser-rum/internal` -> `packages/rum/src/entries/internal`
+- `@datadog/browser-rum-slim` -> `packages/rum-slim/src/entries/main`
+- `@datadog/browser-logs` -> `packages/logs/src/entries/main`
+- `@datadog/browser-rum-react` -> `packages/rum-react/src/entries/main`
+- `@datadog/browser-worker` -> `packages/worker/src/entries/main`
+- `@datadog/browser-flagging` -> `packages/flagging/src/entries/main`
+
+**Test utilities are imported via package `/test` path:**
+```typescript
+import { registerCleanupTask, mockClock } from '@datadog/browser-core/test'
+import { mockRumConfiguration, createPerformanceEntry } from '../../../../test'
+```
+
+## No Side Effects in Production Modules (Critical Convention)
+
+Production source files under `packages/*/src/` must NOT have side effects at module evaluation time. Enforced by the `disallow-side-effects` local ESLint rule in `eslint-local-rules/disallowSideEffects.js`.
+
+**Allowed at module level:**
+- Variable/constant declarations with literal values or pure expressions
+- Function declarations
+- Class declarations (though classes are generally forbidden -- see below)
+- Type declarations
+- Import/export statements (only from packages known to be side-effect-free: `@datadog/browser-core`, `@datadog/browser-rum-core`, `react`, `react-router-dom`)
+
+**NOT allowed at module level:**
+- Function calls (except `Object.keys()`, `.concat()`)
+- `new` expressions (except `RegExp`, `WeakMap`, `WeakSet`, `Set`, `Map`)
+- Any other expression that could run code
+
+**Exception:** Entry point files are allowlisted and may have side effects:
+- `packages/logs/src/entries/main.ts`
+- `packages/flagging/src/entries/main.ts`
+- `packages/rum/src/entries/main.ts`
+- `packages/rum-slim/src/entries/main.ts`
+
+## No Classes in Production Code
+
+Classes are **forbidden** in production source files (`packages/*/src/**/*.ts`, excluding spec files). Enforced by `no-restricted-syntax` rule with `ClassDeclaration`.
+
+**Exceptions:** A few core infrastructure classes exist with `// eslint-disable-next-line no-restricted-syntax` comments:
+- `Observable` and `BufferedObservable` in `packages/core/src/tools/observable.ts`
+- `AbstractLifeCycle` in `packages/core/src/tools/abstractLifeCycle.ts`
+
+Use functions returning object literals instead:
+```typescript
+// Correct pattern:
+export function createContextManager(name: string) {
+  let context: Context = {}
+  const changeObservable = new Observable<void>()
+
+  return {
+    getContext: () => deepClone(context),
+    setContext: (newContext: unknown) => { /* ... */ },
+    clearContext: () => { context = {} },
+    changeObservable,
+  }
+}
+
+// Type derived from return value:
+export type ContextManager = ReturnType<typeof createContextManager>
+```
+
+## No Array Spread in Production Code
+
+Array spread (`[...arr]`) is **forbidden** in production source files. Use `.concat()` instead:
+```typescript
+// Forbidden:
+const combined = [...array1, ...array2]
+
+// Correct:
+const combined = array1.concat(array2)
+```
+
+## No `Date.now()` in Production Code
+
+Direct `Date.now()` calls are **forbidden** in production source files. Use `dateNow()` from the core utilities instead. This enables proper mocking in tests.
+
+## Zone.js Safety
+
+Production code must not directly use Zone.js-patchable DOM APIs. Instead:
+- Use `getZoneJsOriginalValue()` to get unpatched values: `getZoneJsOriginalValue(window, 'setTimeout')`
+- Use the SDK's own wrappers in `packages/core/src/tools/timer.ts`: `setTimeout()`, `clearTimeout()`, `setInterval()`, `clearInterval()`
+- Use `addEventListener()` / `addEventListeners()` from `packages/core/src/browser/addEventListener.ts`
+- Enforced by `disallow-zone-js-patched-values` and `disallow-url-constructor-patched-values` local rules
+
+These wrappers also integrate with the `monitor()` error handling system.
+
+## Error Handling
+
+**Three-tier strategy:**
+
+1. **`monitor()` / `callMonitored()`** - Wraps SDK-internal callbacks to catch errors and report them via telemetry. Used for all callbacks that run in response to browser events, timers, etc.
+   - Location: `packages/core/src/tools/monitor.ts`
+   - Pattern: Wrap callbacks with `monitor(callback)` or use `callMonitored(fn, context, args)`
+   - Errors caught here go to SDK telemetry, not the user's error tracking
+
+2. **`catchUserErrors()`** - Wraps user-provided callbacks to catch and display errors without breaking SDK operation.
+   - Location: `packages/core/src/tools/catchUserErrors.ts`
+   - Pattern: `catchUserErrors(userCallback, 'Error message for display')()`
+   - Errors are displayed via `display.error()` (prefixed with "Datadog Browser SDK:")
+
+3. **`display`** - The SDK's logging utility that preserves original console methods to avoid triggering patched behaviors.
+   - Location: `packages/core/src/tools/display.ts`
+   - Methods: `display.debug()`, `display.log()`, `display.info()`, `display.warn()`, `display.error()`
+   - All messages prefixed with `'Datadog Browser SDK:'`
+   - Never use `console.*` directly in production code (enforced by `no-console` rule)
+
+## Logging
+
+**Framework:** Custom `display` object (wraps original console methods)
+
+**When to log:**
+- Use `display.warn()` for configuration issues the user should fix
+- Use `display.error()` for user callback errors
+- Use `addTelemetryDebug()` / `addTelemetryError()` for internal monitoring
+- Use `addTelemetryMetrics()` for internal metrics
+- Telemetry debug and metrics calls **require** a `// monitor-until: YYYY-MM-DD` or `// monitor-until: forever` comment (enforced by lint rule `enforce-monitor-until-comment`)
+- Expired `monitor-until` dates are reported as warnings/errors by `monitor-until-comment-expired` rule
+
+```typescript
+// monitor-until: 2025-06-01
+addTelemetryDebug('short session investigation', { reason: 'session_expired_early' })
+
+// monitor-until: forever
+addTelemetryMetrics('batch_flushed', { byteCount: payload.bytesCount })
+```
+
+## Mockable Pattern
+
+For values/functions that need to be mocked in tests without dependency injection, use the `mockable()` wrapper:
+
+**In source code (`packages/core/src/tools/mockable.ts`):**
+```typescript
+import { mockable } from '../tools/mockable'
+
+export function formatNavigationEntry(): string {
+  const navigationEntry = mockable(getNavigationEntry)()
+  // ...
+}
+```
+
+**In tests:**
+```typescript
+import { replaceMockable, replaceMockableWithSpy } from '@datadog/browser-core/test'
+
+it('should format navigation entry', () => {
+  replaceMockable(getNavigationEntry, () => FAKE_NAVIGATION_ENTRY)
+  // or for spy-based testing:
+  const spy = replaceMockableWithSpy(getNavigationEntry)
+  // ...
+})
+```
+
+Mocks are automatically cleaned up after each test via `registerCleanupTask()`. In production builds, `mockable()` is a no-op that returns the value as-is. In test builds (when `__BUILD_ENV__SDK_VERSION__ === 'test'`), it checks for registered mock replacements.
+
+## Comments and JSDoc
+
+**JSDoc rules (enforced by `eslint-plugin-jsdoc`):**
+- `check-alignment`: Alignment must be consistent
+- `check-indentation`: Indentation must be consistent
+- `no-blank-blocks`: No empty JSDoc blocks
+- `require-description`: JSDoc blocks must have a description
+- `require-param-description`: `@param` tags must include descriptions
+- `require-hyphen-before-param-description`: `@param name - description` (hyphen required)
+- `no-types`: No JSDoc type annotations in `.ts` files (use TypeScript types instead)
+- `sort-tags`: Tags must follow order: `@category`, `@packageDocumentation`, `@internal`, `@deprecated`, `@experimental`, `@defaultValue`, `@param`, `@return`/`@returns`, `@see`, `@example`
+- `tag-lines`: One blank line after opening `/**`
+
+**When to comment:**
+- Public API types and functions should have JSDoc with `@see` links to Datadog docs where applicable
+- Internal mechanisms that are non-obvious should have block comments explaining "why"
+- Use `@deprecated` with replacement guidance: `@deprecated Use {@link NewThing} instead`
+- Use `@internal` for exports that are not part of the public API
+- Use `@inline` for types that should be inlined in generated documentation
+- Use `@packageDocumentation` at the top of entry point files
+
+**Inline comments:**
+- Spaced comments enforced: `// comment` not `//comment`
+- Use comments to explain workarounds, browser compatibility issues, and non-obvious design decisions
+- Reference GitHub issues and external documentation where relevant
+
+**Example of well-documented entry point (`packages/rum/src/entries/main.ts`):**
+```typescript
+/**
+ * Datadog Browser RUM SDK - Full version with Session Replay capabilities.
+ *
+ * @packageDocumentation
+ * @see [RUM Browser Monitoring Setup](https://docs.datadoghq.com/real_user_monitoring/browser/)
+ */
+```
+
+**Example of documented configuration property:**
+```typescript
+interface InitConfiguration {
+  /**
+   * The client token for Datadog. Required for authenticating your application with Datadog.
+   *
+   * @category Authentication
+   */
+  clientToken: string
+
+  /**
+   * The percentage of sessions tracked. A value between 0 and 100.
+   *
+   * @category Data Collection
+   * @defaultValue 100
+   */
+  sessionSampleRate?: number | undefined
+}
+```
+
+## Function Design
+
+**Return `{ stop }` or `{ unsubscribe }` for cleanup:**
+```typescript
+export function trackFirstContentfulPaint(configuration: RumConfiguration, ...) {
+  const subscription = createPerformanceObservable(configuration, { ... }).subscribe(...)
+  return {
+    stop: subscription.unsubscribe,
+  }
+}
+```
+
+**Prefer functions returning object literals over classes.** Derive types from return values:
+```typescript
+export type Clock = ReturnType<typeof mockClock>
+export type ContextManager = ReturnType<typeof createContextManager>
+export type MockFetchManager = ReturnType<typeof mockFetch>
+```
+
+**Use destructured parameters for options objects:**
+```typescript
+export function createValueHistory<Value>({
+  expireDelay,
+  maxEntries,
+}: {
+  expireDelay: number
+  maxEntries?: number
+}): ValueHistory<Value> {
+  // ...
+}
+```
+
+**Use function overloads for better API ergonomics:**
+```typescript
+export function callMonitored<T extends (...args: any[]) => unknown>(
+  fn: T, context: ThisParameterType<T>, args: Parameters<T>
+): ReturnType<T> | undefined
+export function callMonitored<T extends (this: void) => unknown>(
+  fn: T
+): ReturnType<T> | undefined
+export function callMonitored<T extends (...args: any[]) => unknown>(
+  fn: T, context?: any, args?: any
+): ReturnType<T> | undefined { /* impl */ }
+```
+
+## Module Design
+
+**Exports:**
+- Named exports only. Default exports are **forbidden** except for webpack config files and ESLint rules.
+- Use separate `export type` for type-only exports.
+- Entry points (`packages/*/src/entries/main.ts`) re-export public API from internal modules.
+
+**Index files (`index.ts`):**
+- Use `index.ts` to expose a minimal API in directories where modules work together
+- Do NOT use `index.ts` when a directory contains independent modules
+- An `index.ts` should NOT contain exports only used by spec files
+
+**Example from `packages/core/src/domain/configuration/index.ts`:**
+```typescript
+export type { Configuration, InitConfiguration, ProxyFn } from './configuration'
+export {
+  DefaultPrivacyLevel,
+  TraceContextInjection,
+  isSampleRate,
+  validateAndBuildConfiguration,
+  serializeConfiguration,
+} from './configuration'
+export type { EndpointBuilder, TrackType } from './endpointBuilder'
+export { createEndpointBuilder, buildEndpointHost } from './endpointBuilder'
+export { computeTransportConfiguration, isIntakeUrl } from './transportConfiguration'
+```
+
+**Test utilities directory (`packages/*/test/`):**
+- Each package has a `test/` directory with test utilities
+- Test helpers are exported via `test/index.ts`
+- Mock/emulation helpers live in `test/emulate/` subdirectory
+- Test utilities import from source via relative paths (`../src/...`) or package aliases
+- Test utilities use `export type *` for type-only re-exports: `export type * from './typeUtils'`
+
+**Protected directory imports:**
+- The `disallow-protected-directory-import` local rule prevents cross-directory imports that break encapsulation
+- Exception: Package index files can be imported from test directories
+
+**Tools directory isolation:**
+- `packages/core/src/tools/**` cannot import from `boot/`, `browser/`, `domain/`, or `transport/`
+- Keeps utilities independent and reusable
+
+## TypeScript Usage Patterns
+
+**Strict mode:** Enabled in `tsconfig.base.json` (`"strict": true`)
+
+**Target:** ES2018 for production, ES2020 for module system
+
+**Lib:** `["ES2020", "DOM", "WebWorker"]`
+
+**Type-only imports enforced:**
+```typescript
+import type { Configuration } from '../configuration'  // types
+import { validateAndBuildConfiguration } from '../configuration'  // values
+```
+
+**Branded types for domain values (in `packages/core/src/tools/utils/timeUtils.ts`):**
+```typescript
+export type Duration = number & { d: 'Duration' }
+export type RelativeTime = number & { d: 'RelativeTime' }
+export type TimeStamp = number & { d: 'TimeStamp' }
+export type ServerDuration = number & { d: 'ServerDuration' }
+
+// Usage - cast at boundaries:
+const relative = 1234 as RelativeTime
+```
+
+**`satisfies` operator used for type checking without widening:**
+```typescript
+const transport = {
+  observable: new Observable<HttpRequestEvent>(),
+  send: jasmine.createSpy(),
+  sendOnExit: jasmine.createSpy(),
+} satisfies HttpRequest
+```
+
+**Type guards:**
+```typescript
+export function isError(value: unknown): value is ErrorWithCause {
+  // ...
+}
+
+export function isIndexableObject(value: unknown): value is Record<any, unknown> {
+  return getType(value) === 'object'
+}
+```
+
+**Generic patterns:**
+```typescript
+// Constrained generics for method instrumentation:
+export function instrumentMethod<
+  TARGET extends { [key: string]: any },
+  METHOD extends keyof TARGET
+>(targetPrototype: TARGET, method: METHOD, onPreCall: ...) { ... }
+
+// Mapped types for event systems:
+type EventTypesWithoutData<EventMap> = {
+  [K in keyof EventMap]: EventMap[K] extends void ? K : never
+}[keyof EventMap]
+
+// Recursive partial type:
+export type RecursivePartial<T> = {
+  [P in keyof T]?: T[P] extends Array<infer U>
+    ? Array<RecursivePartial<U>>
+    : T[P] extends object | undefined
+      ? RecursivePartial<T[P]>
+      : T[P]
+}
+```
+
+**`undefined | undefined` pattern for optional properties:**
+```typescript
+// Use `| undefined` explicitly in public API types for better documentation:
+sessionSampleRate?: number | undefined
+```
+
+**Never declare global types in production code:**
+```typescript
+// Forbidden (leaks to user app global scope):
+declare global { ... }
+// Use: TSModuleDeclaration[kind=global] is restricted by no-restricted-syntax
+```
+
+## Build Conventions
+
+**Build system:** Webpack 5 with ts-loader for bundles, TypeScript compiler for CJS/ESM modules
+
+**Build environment variables:** Defined as `__BUILD_ENV__<KEY>__` and replaced at build time via `webpack.DefinePlugin`:
+```typescript
+declare const __BUILD_ENV__SDK_VERSION__: string
+```
+
+**Package outputs:**
+- `cjs/` - CommonJS modules
+- `esm/` - ES modules
+- `bundle/` - Webpack bundles (for CDN distribution)
+
+**All packages mark `"sideEffects": false`** in `package.json` to enable tree shaking.
+
+**Webpack target:** `['web', 'es2018']`
+
+## Commit Messages and PR Conventions
+
+**Commit messages use gitmoji convention:**
+
+User-facing changes:
+- `✨` New feature - New public API, behavior, event, property
+- `🐛` Bug fix - Fix bugs, regressions, crashes
+- `⚡️` Performance - Improve performance, reduce bundle size
+- `💥` Breaking change - Breaking API changes
+- `📝` Documentation - User-facing documentation
+- `⚗️` Experimental - New public feature behind a feature flag
+
+Internal changes:
+- `👷` Build/CI - Dependencies, tooling, deployment, CI config
+- `♻️` Refactor - Code restructuring, architectural changes
+- `🎨` Code structure - Improve code structure, formatting
+- `✅` Tests - Add/fix/improve tests
+- `🔧` Configuration - Config files, project setup
+- `🔥` Removal - Remove code, features, deprecated items
+- `👌` Code review - Address code review feedback
+- `🚨` Linting - Add/fix linter rules
+- `🧹` Cleanup - Minor cleanup, housekeeping
+- `🔊` Logging - Add/modify debug logs, telemetry
+
+**PR conventions:**
+- Branch naming: `<username>/<feature>` (e.g., `john.doe/fix-session-bug`)
+- Always branch from `main`
+- PR title follows commit message convention (used when squashing)
+- PR template at `.github/PULL_REQUEST_TEMPLATE.md` includes:
+  - **Motivation** - Why the change, links to tickets
+  - **Changes** - What changed, who is affected, highlight uncertain changes
+  - **Test instructions** - How to test, steps to reproduce
+  - **Checklist** - Tested locally, tested on staging, unit tests added, e2e tests added, docs updated
+
+## Package Manager
+
+- **Yarn 4.12.0** (Yarn Berry with workspaces). Never use `npm` or `npx`.
+- Node version managed by **Volta**: `25.6.0`
+- Commands: `yarn test:unit`, `yarn lint`, `yarn format`, `yarn build`, `yarn typecheck`
+
+## Key Architectural Patterns to Follow
+
+**Observable pattern:** Use `Observable<T>` for event streams. Subscribe returns `{ unsubscribe }`:
+```typescript
+const observable = new Observable<ViewEvent>()
+const subscription = observable.subscribe((event) => { ... })
+// Later:
+subscription.unsubscribe()
+```
+
+**BufferedObservable pattern:** For events that need to buffer data before subscribers are ready:
+```typescript
+const observable = new BufferedObservable<string>(100)
+observable.notify('data')  // buffered until subscriber arrives
+observable.subscribe((data) => { ... })  // receives buffered data asynchronously
+observable.unbuffer()  // stop buffering when no longer needed
+```
+
+**LifeCycle pattern:** Use typed `AbstractLifeCycle<EventMap>` for domain event buses:
+```typescript
+// Define (packages/rum-core/src/domain/lifeCycle.ts):
+export const LifeCycle = AbstractLifeCycle<LifeCycleEventMap>
+export type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>
+
+// Use:
+lifeCycle.subscribe(LifeCycleEventType.VIEW_CREATED, (event) => { ... })
+lifeCycle.notify(LifeCycleEventType.VIEW_UPDATED, viewEvent)
+```
+
+**Hooks pattern:** Use `abstractHooks()` for assembly/transformation pipelines:
+```typescript
+hooks.register(HookNames.Assemble, (param) => { ... })
+const result = hooks.triggerHook(HookNames.Assemble, eventData)
+// Returns DISCARDED, SKIPPED, or combined results
+```
+
+**ValueHistory pattern:** Track time-bounded values:
+```typescript
+const viewHistory = createValueHistory<ViewContext>({ expireDelay: SESSION_TIME_OUT_DELAY })
+const entry = viewHistory.add(viewContext, startTime)
+entry.close(endTime)
+const current = viewHistory.find()
+```
+
+**instrumentMethod pattern:** Safely patch browser APIs:
+```typescript
+const { stop } = instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {
+  // Before fetch is called
+  onPostCall((result) => {
+    // After fetch returns
+  })
+})
+// Later: stop() to restore original
+```
+
+## Event Type Properties Convention
+
+Event type files (`*Event.types.ts`) enforce snake_case for properties and UPPER_CASE for object literal properties:
+```typescript
+// In *Event.types.ts files:
+interface RawRumResourceEvent {
+  resource: {
+    status_code?: number        // snake_case properties
+    encoded_body_size?: number
+    transfer_size?: number
+  }
+}
+```
+
+---
+
+*Convention analysis: 2026-02-16*
diff --git a/.planning/codebase/INTEGRATIONS.md b/.planning/codebase/INTEGRATIONS.md
new file mode 100644
index 0000000000..318e09ec35
--- /dev/null
+++ b/.planning/codebase/INTEGRATIONS.md
@@ -0,0 +1,168 @@
+# External Integrations
+
+**Analysis Date:** 2026-01-21
+
+## APIs & External Services
+
+**Datadog Intake API:**
+- Service: Datadog telemetry ingestion endpoints
+  - SDK/Client: Custom `httpRequest` implementation in `packages/core/src/transport/httpRequest.ts`
+  - Endpoints: `/api/v2/{logs|rum|replay|profile|exposures|flagevaluation}`
+  - Auth: Client token via query parameter (`dd-api-key`)
+  - Sites supported: Multiple regions (US1, US3, US5, EU1, AP1, AP2, GovCloud)
+  - Default site: `datadoghq.com` (US1)
+  - PCI compliance: Special intake host for PCI-compliant logs (`pci.browser-intake-datadoghq.com`)
+
+**Remote Configuration:**
+- Service: Datadog remote configuration API
+  - Implementation: `packages/rum-core/src/domain/configuration/remoteConfiguration.ts`
+  - Purpose: Dynamic feature flag and configuration updates
+
+**Session Replay:**
+- Service: Datadog Session Replay ingestion
+  - Endpoint: `/api/v2/replay`
+  - Compression: Deflate encoding via Web Workers
+  - Worker implementation: `packages/worker/src/boot/startWorker.ts`
+
+**Proxy Support:**
+- Custom proxy configuration available
+  - String proxy: URL-based forwarding with `ddforward` parameter
+  - Function proxy: Custom request transformation
+
+## Data Storage
+
+**Databases:**
+- None - This is a client-side SDK
+
+**Browser Storage:**
+- Cookies
+  - Implementation: `packages/core/src/browser/cookie.ts`
+  - Usage: Session management, user tracking
+  - Options: Secure, SameSite, cross-site, partitioned, domain configuration
+  - Cookie names managed by SDK (session IDs, configuration)
+
+**File Storage:**
+- Local filesystem only (for development/testing)
+- No cloud storage services used by SDK
+
+**Caching:**
+- Browser-native caching only
+- No external caching services
+
+## Authentication & Identity
+
+**Auth Provider:**
+- Custom (Datadog client token authentication)
+  - Implementation: Token passed via initialization configuration
+  - Transmitted as query parameter (`dd-api-key`)
+  - No OAuth or third-party auth services
+
+**Session Management:**
+- Cookie-based sessions
+  - Session manager: `packages/rum-core/src/domain/rumSessionManager.spec.ts`
+  - Tracks user sessions across page loads
+  - Configurable session timeout and renewal
+
+## Monitoring & Observability
+
+**Error Tracking:**
+- Self-monitoring via Datadog RUM
+  - Implementation: `packages/core/src/tools/monitor.ts`
+  - Reports SDK errors to configured Datadog instance
+
+**Logs:**
+- Custom logging to Datadog Logs API
+  - Package: `@datadog/browser-logs`
+  - Endpoint: `/api/v2/logs`
+
+**Telemetry:**
+- Internal telemetry tracking
+  - Types: `packages/core/src/domain/telemetry/telemetryEvent.types.ts`
+  - Tracks SDK performance and usage metrics
+
+## CI/CD & Deployment
+
+**Hosting:**
+- NPM Registry - Published packages
+  - Org: `@datadog/*`
+  - Public access for all packages
+- Chrome Web Store - Developer extension
+  - Upload script: `scripts/deploy/publish-developer-extension.ts`
+  - Package: `chrome-webstore-upload` 4.0.3
+
+**CI Pipeline:**
+- GitLab CI (primary)
+  - Config: `.gitlab-ci.yml`
+  - Docker image: `registry.ddbuild.io/ci/browser-sdk:97`
+  - Stages: test, browserstack, pre-deploy, deploy, notify
+- GitHub Actions (auxiliary)
+  - Workflows: CLA, CodeQL, docs deployment, Confluence changelog sync
+
+**Source Maps:**
+- Upload to Datadog
+  - Script: `scripts/deploy/upload-source-maps.ts`
+  - Purpose: Error debugging in production
+
+**BrowserStack:**
+- Service: Cross-browser testing platform
+  - Client: `browserstack-local` 1.5.8
+  - Wrapper: `scripts/test/bs-wrapper.ts`
+  - Karma config: `test/unit/karma.bs.conf.js`
+  - Playwright config: `test/e2e/playwright.bs.config.ts`
+
+## Environment Configuration
+
+**Required env vars:**
+- `DD_API_KEY` or client token - For Datadog intake authentication
+- `BROWSERSTACK_USERNAME` - BrowserStack authentication
+- `BROWSERSTACK_ACCESS_KEY` - BrowserStack authentication
+- Build environment variables injected at compile time (SDK version)
+
+**Secrets location:**
+- GitLab CI variables (for deployment)
+- Local environment for development
+- No `.env` files in repository
+
+## Webhooks & Callbacks
+
+**Incoming:**
+- None - Client-side SDK only
+
+**Outgoing:**
+- Datadog Intake API endpoints (POST requests)
+  - `/api/v2/rum` - RUM events
+  - `/api/v2/logs` - Log events
+  - `/api/v2/replay` - Session replay segments
+  - `/api/v2/profile` - Profiling data
+  - `/api/v2/exposures` - Feature flag exposures
+  - `/api/v2/flagevaluation` - Feature flag evaluations
+
+**Request Strategies:**
+- `fetch` with keepalive - Primary method
+- `fetch` without keepalive - Experimental feature fallback
+- `sendBeacon` - For page exit events
+- Retry strategy: `packages/core/src/transport/sendWithRetryStrategy.ts`
+
+## Third-Party Integrations
+
+**React:**
+- Integration package: `@datadog/browser-rum-react`
+- Supports React Router v6 and v7
+- Automatic view tracking for SPAs
+
+**UI Libraries (Developer Extension):**
+- Mantine Core 8.3.12 - UI component library
+- Tabler Icons 3.36.1 - Icon set
+
+**CI Visibility:**
+- Integration detection: `packages/rum-core/src/domain/contexts/ciVisibilityContext.ts`
+- Reads CI environment variables and cookies
+
+**Synthetics:**
+- Datadog Synthetics detection
+  - Context: `packages/rum-core/src/domain/contexts/syntheticsContext.spec.ts`
+  - Special handling for synthetic browser tests
+
+---
+
+*Integration audit: 2026-01-21*
diff --git a/.planning/codebase/STACK.md b/.planning/codebase/STACK.md
new file mode 100644
index 0000000000..801d791784
--- /dev/null
+++ b/.planning/codebase/STACK.md
@@ -0,0 +1,110 @@
+# Technology Stack
+
+**Analysis Date:** 2026-01-21
+
+## Languages
+
+**Primary:**
+- TypeScript 5.9.3 - All source code across packages
+- JavaScript - Build scripts and configuration files
+
+**Secondary:**
+- JSX/TSX - React components in developer extension and React integration package
+
+## Runtime
+
+**Environment:**
+- Node.js 25.3.0 (managed via Volta)
+- Browser environments (ES2018+ target)
+- Web Workers (for deflate compression)
+
+**Package Manager:**
+- Yarn 4.12.0 (Berry)
+- Lockfile: `yarn.lock` present
+- Workspace-based monorepo structure
+
+## Frameworks
+
+**Core:**
+- Custom browser SDK (no external framework dependencies for SDK packages)
+- React 19.2.3 - Used in developer extension and React integration package
+- React Router 6.x/7.x - Peer dependency for `@datadog/browser-rum-react`
+
+**Testing:**
+- Karma 6.4.4 - Unit test runner
+- Jasmine 3.99.1 - Test framework and assertions
+- Playwright 1.57.0 - E2E testing
+- BrowserStack - Cross-browser testing
+
+**Build/Dev:**
+- Webpack 5.104.1 - Bundling
+- TypeScript Compiler 5.9.3 - Module builds (ESM/CJS)
+- ts-loader 9.5.4 - Webpack TypeScript integration
+- swc-loader 0.2.6 - Fast TypeScript/JavaScript compilation
+- TerserPlugin 5.3.16 - Minification
+- WXT 0.20.13 - Browser extension development (developer-extension)
+
+## Key Dependencies
+
+**Critical:**
+- pako 2.1.0 - Deflate compression for payload optimization
+- No external runtime dependencies (SDK packages are self-contained)
+
+**Infrastructure:**
+- undici 7.18.2 - HTTP client for Node.js scripts
+- express 5.2.1 - Dev server
+- lerna 9.0.3 - Monorepo management
+- typedoc 0.28.16 - API documentation generation
+
+**Development:**
+- eslint 9.39.2 - Linting with typescript-eslint 8.52.0
+- prettier 3.7.4 - Code formatting
+- karma-coverage-istanbul-reporter 3.0.3 - Code coverage
+- puppeteer 24.34.0 - Browser automation for tests
+
+## Configuration
+
+**Environment:**
+- No `.env` files detected (configuration passed via initialization)
+- Build environment variables injected via `__BUILD_ENV__SDK_VERSION__` at build time
+- SDK configuration via runtime initialization (clientToken, applicationId, site, etc.)
+
+**Build:**
+- `tsconfig.base.json` - Base TypeScript configuration
+- `tsconfig.webpack.json` - Webpack-specific TypeScript config
+- `tsconfig.default.json` - Default for uncategorized files
+- `tsconfig.scripts.json` - Build scripts configuration
+- `webpack.base.ts` - Shared Webpack configuration
+- `.prettierrc.yml` - Code formatting rules
+- `eslint.config.mjs` - ESLint 9 flat config
+
+**TypeScript:**
+- Target: ES2018
+- Module: ES2020
+- Strict mode enabled
+- Path aliases for internal packages (`@datadog/browser-*`)
+- Multiple build outputs: ESM (`esm/`), CJS (`cjs/`), and bundled (`bundle/`)
+
+## Platform Requirements
+
+**Development:**
+- Node.js 25.3.0+
+- Yarn 4.12.0
+- Chrome for unit tests (Karma with ChromeHeadless)
+- Chromium for E2E tests (Playwright)
+
+**Production:**
+- Browser: ES2018+ support required
+- Target platforms: Web browsers (Chrome, Firefox, Safari, Edge)
+- Web Workers support for compression features
+- Cookie support for session management
+
+**CI/CD:**
+- GitLab CI (`.gitlab-ci.yml`) - Primary CI pipeline
+- GitHub Actions (`.github/workflows/`) - Auxiliary workflows
+- BrowserStack integration for cross-browser testing
+- Docker-based CI image: `registry.ddbuild.io/ci/browser-sdk`
+
+---
+
+*Stack analysis: 2026-01-21*
diff --git a/.planning/codebase/STRUCTURE.md b/.planning/codebase/STRUCTURE.md
new file mode 100644
index 0000000000..5a6775cb41
--- /dev/null
+++ b/.planning/codebase/STRUCTURE.md
@@ -0,0 +1,282 @@
+# Codebase Structure
+
+**Analysis Date:** 2026-01-21
+
+## Directory Layout
+
+```
+browser-sdk/
+├── packages/                # 8 npm packages (monorepo)
+│   ├── core/               # Foundation library
+│   ├── rum-core/           # RUM business logic
+│   ├── rum/                # Full RUM with replay
+│   ├── rum-slim/           # Lightweight RUM
+│   ├── logs/               # Logs SDK
+│   ├── rum-react/          # React integration
+│   ├── worker/             # Web worker for compression
+│   └── flagging/           # Feature flagging
+├── test/                   # Test infrastructure
+│   ├── unit/               # Karma unit tests
+│   ├── e2e/                # Playwright E2E tests
+│   ├── performance/        # Performance benchmarks
+│   └── apps/               # Test applications
+├── scripts/                # Build and release automation
+├── developer-extension/    # Browser DevTools extension
+├── rum-events-format/      # JSON schemas (submodule)
+├── sandbox/                # Development playground
+└── remote-configuration/   # Remote config schemas
+```
+
+## Directory Purposes
+
+**packages/core:**
+- Purpose: Shared foundation library for all SDK products
+- Contains: Browser API wrappers, observables, transport layer, session management, configuration, utilities
+- Key files: `src/index.ts` (exports), `src/transport/batch.ts`, `src/domain/session/sessionManager.ts`, `src/browser/xhrObservable.ts`
+
+**packages/rum-core:**
+- Purpose: RUM business logic without product-specific features
+- Contains: Event collections (views, actions, errors, resources, long tasks, vitals), assembly, contexts, tracing
+- Key files: `src/index.ts` (exports), `src/boot/startRum.ts`, `src/domain/lifeCycle.ts`, `src/domain/assembly.ts`
+
+**packages/rum:**
+- Purpose: Full RUM SDK with Session Replay and Real User Profiling
+- Contains: Public API, recorder integration, profiler integration, deflate encoder
+- Key files: `src/entries/main.ts` (entry point), `src/boot/recorderApi.ts`, `src/boot/profilerApi.ts`
+
+**packages/rum-slim:**
+- Purpose: Lightweight RUM without replay for smaller bundle size
+- Contains: Public API with recorder stub
+- Key files: `src/entries/main.ts` (entry point)
+
+**packages/logs:**
+- Purpose: Browser log collection SDK
+- Contains: Log assembly, log handlers, log context management
+- Key files: `src/entries/main.ts` (entry point), `src/domain/logsAssembly.ts`
+
+**packages/rum-react:**
+- Purpose: React-specific RUM enhancements
+- Contains: Error boundary, React Router integration, performance hooks
+- Key files: `src/entries/main.ts`, `src/domain/error/errorBoundary.ts`, `src/domain/reactRouter/index.ts`
+
+**packages/worker:**
+- Purpose: Web Worker for background compression
+- Contains: Deflate implementation for worker context
+- Key files: `src/entries/main.ts`, `src/boot/startWorker.ts`
+
+**packages/flagging:**
+- Purpose: Feature flag integration (experimental)
+- Contains: Feature flag context management
+- Key files: `src/entries/main.ts`
+
+**test/unit:**
+- Purpose: Karma-based unit tests
+- Contains: Test configuration and fixtures
+- Key files: `karma.local.conf.js`, `karma.bs.conf.js`
+
+**test/e2e:**
+- Purpose: Playwright end-to-end tests
+- Contains: Test scenarios, helpers, test apps
+- Key files: `playwright.local.config.ts`, `scenario/rum/`, `scenario/recorder/`
+
+**test/performance:**
+- Purpose: Performance benchmarks
+- Contains: Profilers, scenarios, reporters
+- Key files: `playwright.config.ts`, `scenarios/`, `profilers/`
+
+**test/apps:**
+- Purpose: Test applications for E2E and manual testing
+- Contains: Vanilla JS, React, React Router test apps
+- Key files: `vanilla/`, `react-heavy-spa/`, `react-router-v6-app/`
+
+**scripts:**
+- Purpose: Build, release, and deployment automation
+- Contains: Package builder, changelog generator, deployment scripts, CLI
+- Key files: `build/build-package.ts`, `release/`, `deploy/`, `cli`
+
+**developer-extension:**
+- Purpose: Chrome/Firefox DevTools panel for debugging SDK
+- Contains: Extension UI, background scripts, content scripts
+- Key files: `src/panel/`, `src/background/`, `manifest.json`
+
+**rum-events-format:**
+- Purpose: JSON schemas for RUM/Log events (Git submodule)
+- Contains: Schema definitions for event validation
+- Key files: `schemas/`
+
+## Key File Locations
+
+**Entry Points:**
+- `packages/rum/src/entries/main.ts`: Full RUM SDK entry
+- `packages/rum-slim/src/entries/main.ts`: Slim RUM SDK entry
+- `packages/logs/src/entries/main.ts`: Logs SDK entry
+- `packages/rum-react/src/entries/main.ts`: React plugin entry
+- `packages/rum-react/src/entries/reactRouterV6.ts`: React Router v6 integration
+- `packages/rum-react/src/entries/reactRouterV7.ts`: React Router v7 integration
+- `packages/worker/src/entries/main.ts`: Worker entry
+
+**Configuration:**
+- `package.json`: Root workspace config
+- `lerna.json`: Lerna monorepo config
+- `tsconfig.base.json`: Base TypeScript config with path aliases
+- `tsconfig.json`: Root TypeScript project config
+- `eslint.config.mjs`: ESLint configuration
+- `.prettierrc.yml`: Prettier formatting config
+- `webpack.base.ts`: Webpack configuration for bundling
+
+**Core Logic:**
+- `packages/core/src/index.ts`: Core library exports
+- `packages/core/src/tools/observable.ts`: Observable implementation
+- `packages/core/src/transport/batch.ts`: Batch transport
+- `packages/core/src/domain/session/sessionManager.ts`: Session lifecycle
+- `packages/rum-core/src/boot/startRum.ts`: RUM initialization
+- `packages/rum-core/src/domain/lifeCycle.ts`: Event bus
+- `packages/rum-core/src/domain/assembly.ts`: Event enrichment
+- `packages/rum-core/src/boot/rumPublicApi.ts`: Public API builder
+
+**Testing:**
+- `test/unit/karma.local.conf.js`: Local unit test runner
+- `test/e2e/playwright.local.config.ts`: Local E2E test config
+- `packages/*/test/`: Package-specific test files (co-located with `*.spec.ts`)
+
+## Naming Conventions
+
+**Files:**
+- `*.ts`: TypeScript source files
+- `*.spec.ts`: Unit test files (co-located with source)
+- `*.types.ts`: Type definition files
+- `index.ts`: Package entry point or barrel file
+- `main.ts`: Primary entry point in `entries/` directories
+- `*.config.ts`/`*.config.js`: Configuration files
+
+**Directories:**
+- `src/`: Source code
+- `test/`: Test files
+- `domain/`: Domain logic modules
+- `boot/`: Initialization/startup code
+- `browser/`: Browser API integrations
+- `transport/`: Data transmission layer
+- `tools/`: Utilities and helpers
+- `entries/`: Package entry points
+- `contexts/`: Context management modules
+
+## Where to Add New Code
+
+**New RUM Event Type:**
+- Primary code: `packages/rum-core/src/domain/{event-type}/`
+- Create collection module following pattern in `domain/action/actionCollection.ts`
+- Add event type to `rawRumEvent.types.ts` and `rumEvent.types.ts`
+- Register in `boot/startRum.ts` to wire up LifeCycle
+- Tests: `packages/rum-core/src/domain/{event-type}/*.spec.ts`
+
+**New Browser Observable:**
+- Implementation: `packages/core/src/browser/{feature}Observable.ts`
+- Export from: `packages/core/src/index.ts`
+- Tests: `packages/core/src/browser/{feature}Observable.spec.ts`
+
+**New Context Type:**
+- Implementation: `packages/core/src/domain/contexts/{context}Context.ts` or `packages/rum-core/src/domain/contexts/{context}Context.ts`
+- Wire up in: `packages/rum-core/src/boot/startRum.ts`
+- Tests: Co-located `*.spec.ts` file
+
+**New Transport Feature:**
+- Implementation: `packages/core/src/transport/{feature}.ts`
+- Export from: `packages/core/src/transport/index.ts`
+- Tests: `packages/core/src/transport/{feature}.spec.ts`
+
+**New Configuration Option:**
+- Type definitions: `packages/core/src/domain/configuration/configuration.ts` or `packages/rum-core/src/domain/configuration/configuration.ts`
+- Validation: Same file, in `validateAndBuildConfiguration()`
+- Tests: `*.spec.ts` in same directory
+
+**New Public API Method:**
+- For RUM: `packages/rum-core/src/boot/rumPublicApi.ts`
+- For Logs: `packages/logs/src/boot/logsPublicApi.ts`
+- Add to type definition and implementation
+- Export types from package `index.ts`
+
+**Utilities:**
+- Shared helpers: `packages/core/src/tools/` (organized by category: `utils/`, `serialisation/`, `stackTrace/`)
+- Domain-specific: In relevant domain module directory
+
+## Special Directories
+
+**node_modules:**
+- Purpose: Dependency storage (Yarn v4 with PnP)
+- Generated: Yes
+- Committed: No (.gitignored)
+
+**cjs/ and esm/:**
+- Purpose: Compiled output directories for CommonJS and ES modules
+- Generated: Yes (by `scripts/build/build-package.ts`)
+- Committed: No (build artifacts)
+
+**docs:**
+- Purpose: Generated TypeDoc API documentation
+- Generated: Yes (by `typedoc`)
+- Committed: No
+
+**.planning:**
+- Purpose: GSD codebase analysis and planning documents
+- Generated: Yes (by /gsd commands)
+- Committed: Depends on team workflow
+
+**rum-events-format:**
+- Purpose: JSON schemas for event format validation
+- Generated: No (Git submodule, external repository)
+- Committed: Submodule reference committed
+
+**bundle/:**
+- Purpose: Webpack bundled output for CDN distribution
+- Generated: Yes (by build scripts)
+- Committed: No
+
+**developer-extension/dist:**
+- Purpose: Built browser extension
+- Generated: Yes
+- Committed: No
+
+## Package Internal Structure
+
+Each SDK package follows a consistent structure:
+
+```
+packages/{package}/
+├── src/
+│   ├── entries/          # Entry points (main.ts, internal.ts, etc.)
+│   ├── boot/             # Initialization logic
+│   ├── domain/           # Business logic modules
+│   ├── browser/          # Browser API wrappers (rum-core only)
+│   ├── transport/        # Transport layer (if package-specific)
+│   └── types/            # Type definitions
+├── test/                 # Package-specific test utilities
+├── package.json          # Package manifest
+└── tsconfig.json         # Package TypeScript config (extends base)
+```
+
+**Typical domain module structure:**
+- `{feature}Collection.ts`: Main collection logic
+- `track{Feature}.ts`: Specific tracking implementations
+- `{feature}.types.ts`: Type definitions
+- `*.spec.ts`: Unit tests (co-located)
+
+## Build Output Structure
+
+After build, packages contain:
+
+```
+packages/{package}/
+├── cjs/                  # CommonJS output (Node.js)
+│   ├── index.js
+│   ├── index.d.ts
+│   └── ...
+├── esm/                  # ES Module output (bundlers)
+│   ├── index.js
+│   └── ...
+└── bundle/               # Webpack bundle (CDN) - rum/logs only
+    └── datadog-{product}.js
+```
+
+---
+
+*Structure analysis: 2026-01-21*
diff --git a/.planning/codebase/TESTING.md b/.planning/codebase/TESTING.md
new file mode 100644
index 0000000000..fa4e4ee5da
--- /dev/null
+++ b/.planning/codebase/TESTING.md
@@ -0,0 +1,444 @@
+# Testing Patterns
+
+**Analysis Date:** 2026-01-21
+
+## Test Framework
+
+**Runner:**
+- Karma 6.4.4
+- Config: `test/unit/karma.base.conf.js`, `test/unit/karma.local.conf.js`, `test/unit/karma.bs.conf.js`
+
+**Assertion Library:**
+- Jasmine 3.99.1 (built-in with Karma)
+
+**Run Commands:**
+```bash
+yarn test                       # Run unit tests in watch mode
+yarn test:unit                  # Run all unit tests once
+yarn test:unit:watch            # Run tests in watch mode
+yarn test:unit:bs               # Run tests on BrowserStack
+yarn test:e2e                   # Run E2E tests with Playwright
+yarn test:e2e:init              # Build and prepare E2E tests
+```
+
+## Test File Organization
+
+**Location:**
+- Co-located with source files: `packages/*/src/**/*.spec.ts`
+- Dedicated test utilities: `packages/core/test/**/*.ts`
+- E2E tests: `test/e2e/**/*.ts` (Playwright)
+- Performance tests: `test/performance/**/*.ts`
+
+**Naming:**
+- Unit tests: `*.spec.ts` or `*.spec.tsx` (React components)
+- Test helpers: camelCase without `.spec` suffix (e.g., `mockClock.ts`, `fakeSessionStoreStrategy.ts`)
+
+**Structure:**
+```
+packages/core/
+├── src/
+│   ├── domain/
+│   │   ├── session/
+│   │   │   ├── sessionStore.ts
+│   │   │   └── sessionStore.spec.ts       # Co-located test
+│   └── tools/
+│       ├── observable.ts
+│       └── observable.spec.ts
+└── test/
+    ├── index.ts                            # Barrel export of utilities
+    ├── emulate/
+    │   ├── mockClock.ts                    # Test utility
+    │   └── mockFetch.ts
+    └── wait.ts
+```
+
+## Test Structure
+
+**Suite Organization:**
+```typescript
+import type { Clock } from '@datadog/browser-core/test'
+import { mockClock, registerCleanupTask } from '@datadog/browser-core/test'
+import { functionToTest } from './moduleUnderTest'
+
+describe('module name', () => {
+  let clock: Clock
+  let dependency: jasmine.Spy
+
+  beforeEach(() => {
+    clock = mockClock()
+    dependency = jasmine.createSpy('dependency name')
+  })
+
+  afterEach(() => {
+    // Cleanup handled automatically by registerCleanupTask
+  })
+
+  describe('nested feature', () => {
+    it('should do something specific', () => {
+      const result = functionToTest()
+      expect(result).toBe(expectedValue)
+    })
+
+    it('should handle edge case', () => {
+      // Test implementation
+    })
+  })
+})
+```
+
+**Patterns:**
+- Use `describe()` to group related tests by module/feature
+- Nested `describe()` blocks for sub-features or scenarios
+- `beforeEach()` for test setup
+- `afterEach()` for cleanup (though `registerCleanupTask` auto-cleanup is preferred)
+- One assertion focus per `it()` block when possible
+
+## Mocking
+
+**Framework:** Jasmine spies (built-in)
+
+**Patterns:**
+
+**Spy Creation:**
+```typescript
+// Basic spy
+const callback = jasmine.createSpy('callback name')
+expect(callback).toHaveBeenCalled()
+
+// Spy on existing object method
+const displaySpy = spyOn(display, 'error')
+expect(displaySpy).toHaveBeenCalledWith('message', error)
+
+// Spy with return value
+const mockFunction = jasmine.createSpy('fn').and.returnValue(42)
+
+// Spy with callback
+const mockWithCallback = jasmine.createSpy('fn').and.callFake((arg) => {
+  return arg * 2
+})
+
+// Spy on object property
+spyOn(performance, 'now').and.callFake(() => Date.now() - timeOrigin)
+```
+
+**Clock Mocking:**
+```typescript
+import type { Clock } from '@datadog/browser-core/test'
+import { mockClock } from '@datadog/browser-core/test'
+
+beforeEach(() => {
+  clock = mockClock()
+})
+
+it('advances time', () => {
+  const startTime = clock.relative(0)
+  clock.tick(1000)
+  const endTime = clock.relative(1000)
+})
+```
+
+**XHR/Fetch Mocking:**
+```typescript
+import { mockFetch } from '@datadog/browser-core/test'
+
+const fetch = mockFetch()
+// Fetch will return controlled responses
+```
+
+**Event Target Mocking:**
+```typescript
+import { mockEventTarget } from '@datadog/browser-core/test'
+
+const eventTarget = mockEventTarget()
+eventTarget.addEventListener('click', handler)
+```
+
+**What to Mock:**
+- External dependencies (APIs, browser APIs)
+- Time-dependent functions (use `mockClock()`)
+- Global objects that change state
+- Callbacks to verify invocation
+- Browser APIs not available in test environment
+
+**What NOT to Mock:**
+- Pure utility functions
+- Simple data transformations
+- Type definitions
+- Constants
+- Internal implementation details of the module under test
+
+## Fixtures and Factories
+
+**Test Data:**
+```typescript
+// Inline fixture data
+const FAKE_CSP_VIOLATION_EVENT = {
+  type: 'securitypolicyviolation',
+  // ... properties
+}
+
+// Factory functions for test data
+function createFakeSessionStoreStrategy(): SessionStoreStrategy {
+  return {
+    persistSession: jasmine.createSpy('persistSession'),
+    retrieveSession: jasmine.createSpy('retrieveSession'),
+    expireSession: jasmine.createSpy('expireSession'),
+  }
+}
+
+// Test builders
+function buildLocation(url: string): Location {
+  const urlObject = new URL(url)
+  return {
+    href: urlObject.href,
+    pathname: urlObject.pathname,
+    // ... other properties
+  }
+}
+```
+
+**Location:**
+- Shared fixtures in `packages/core/test/` directory
+- Inline fixtures for test-specific data
+- Factory functions prefixed with `create*`, `build*`, `fake*`, or `mock*`
+
+## Coverage
+
+**Requirements:** Not explicitly enforced (no minimum threshold configured)
+
+**View Coverage:**
+```bash
+# Coverage is collected via karma-coverage-istanbul-reporter
+# Reports generated in coverage/ directory when tests run
+yarn test:unit
+```
+
+**Configuration:**
+- Istanbul coverage via `@jsdevtools/coverage-istanbul-loader`
+- Configured in `test/unit/karma.base.conf.js`
+- Coverage for source files only (excludes test files)
+
+## Test Types
+
+**Unit Tests:**
+- Scope: Individual functions, modules, and classes
+- Located: Co-located with source files (`*.spec.ts`)
+- Approach: Isolated testing with mocked dependencies
+- Fast execution, no external dependencies
+- Run via Karma in actual browsers (Chrome by default)
+
+**Integration Tests:**
+- Scope: Module interactions within packages
+- Approach: Testing multiple modules together with minimal mocking
+- Located: Same as unit tests but with broader scope
+- Test real observable patterns, event lifecycle, session management flows
+
+**E2E Tests:**
+- Framework: Playwright 1.57.0
+- Scope: Full browser scenarios, user flows
+- Located: `test/e2e/**/*.ts`
+- Config: `test/e2e/playwright.local.config.ts`, `test/e2e/playwright.bs.config.ts`
+- Run against built test applications
+
+## Common Patterns
+
+**Async Testing:**
+```typescript
+import { waitNextMicrotask } from '@datadog/browser-core/test'
+
+it('handles async operations', async () => {
+  observable.notify('data')
+
+  // Wait for microtask queue to flush
+  await waitNextMicrotask()
+
+  expect(observer).toHaveBeenCalledWith('data')
+})
+
+// Using done callback (less common)
+it('handles callbacks', (done) => {
+  asyncOperation(() => {
+    expect(result).toBe(expected)
+    done()
+  })
+})
+```
+
+**Error Testing:**
+```typescript
+it('throws error for invalid input', () => {
+  expect(() => {
+    dangerousFunction(invalidInput)
+  }).toThrow()
+})
+
+it('catches and handles errors', () => {
+  const error = new Error('test error')
+  const displaySpy = spyOn(display, 'error')
+
+  functionThatCatchesError(error)
+
+  expect(displaySpy).toHaveBeenCalledWith('Error message', error)
+})
+
+// Testing error properties
+it('formats error correctly', () => {
+  const result = computeRawError({
+    originalError: new TypeError('oh snap!'),
+    handling: ErrorHandling.HANDLED,
+  })
+
+  expect(result.message).toEqual('oh snap!')
+  expect(result.type).toEqual('TypeError')
+  expect(result.stack).toEqual(jasmine.stringMatching('TypeError: oh snap!'))
+})
+```
+
+**Observable Testing:**
+```typescript
+import { Observable } from './observable'
+
+it('notifies subscribers', () => {
+  const observable = new Observable<string>()
+  const subscriber = jasmine.createSpy('subscriber')
+
+  observable.subscribe(subscriber)
+  observable.notify('test data')
+
+  expect(subscriber).toHaveBeenCalledWith('test data')
+  expect(subscriber).toHaveBeenCalledTimes(1)
+})
+
+it('allows unsubscribe', () => {
+  const subscription = observable.subscribe(subscriber)
+  subscription.unsubscribe()
+
+  observable.notify('data')
+  expect(subscriber).not.toHaveBeenCalled()
+})
+```
+
+**Parameterized Tests:**
+```typescript
+;[
+  {
+    testCase: 'an error instance',
+    error: new Error('foo'),
+    message: 'foo',
+    type: 'Error',
+  },
+  {
+    testCase: 'a string',
+    error: 'foo',
+    message: 'Provided "foo"',
+    type: undefined,
+  },
+].forEach(({ testCase, error, message, type }) => {
+  it(`handles ${testCase}`, () => {
+    const result = computeRawError({ originalError: error })
+    expect(result.message).toEqual(message)
+    expect(result.type).toEqual(type)
+  })
+})
+```
+
+**Jasmine Matchers:**
+```typescript
+// Common matchers used in codebase
+expect(value).toBe(expected)                    // Strict equality
+expect(value).toEqual(expected)                 // Deep equality
+expect(value).toBeDefined()
+expect(value).toBeUndefined()
+expect(fn).toHaveBeenCalled()
+expect(fn).toHaveBeenCalledTimes(3)
+expect(fn).toHaveBeenCalledWith(arg1, arg2)
+expect(fn).toHaveBeenCalledOnceWith(arg)
+expect(str).toMatch(/regex/)
+expect(str).toEqual(jasmine.stringMatching('pattern'))
+expect(obj).toEqual(jasmine.objectContaining({ key: value }))
+expect(value).toEqual(jasmine.any(String))
+```
+
+## Test Utilities
+
+**Available in `@datadog/browser-core/test`:**
+
+- `mockClock()` - Mock time and Date functions
+- `mockFetch()` - Mock fetch API
+- `mockXhr()` - Mock XMLHttpRequest
+- `mockEventTarget()` - Create fake event target
+- `mockZoneJs()` - Mock Zone.js patched globals
+- `mockNavigator()` - Mock navigator object
+- `mockEventBridge()` - Mock event bridge for extensions
+- `buildLocation(url)` - Create Location object from URL
+- `createNewEvent(type)` - Create DOM events
+- `waitNextMicrotask()` - Wait for microtask queue
+- `registerCleanupTask(fn)` - Auto-cleanup after test
+- `collectAsyncCalls(fn)` - Track async function calls
+- `interceptRequests()` - Intercept HTTP requests
+- `fakeSessionStoreStrategy()` - Mock session storage
+
+**Usage Example:**
+```typescript
+import { mockClock, registerCleanupTask, waitNextMicrotask } from '@datadog/browser-core/test'
+
+beforeEach(() => {
+  const clock = mockClock()
+  // Cleanup registered automatically
+
+  registerCleanupTask(() => {
+    // Custom cleanup if needed
+  })
+})
+```
+
+## Webpack Configuration
+
+**Test Build:**
+- Mode: development
+- Module bundling: Each spec gets own bundle (no shared dependencies)
+- Source maps: Enabled via `karma-sourcemap-loader`
+- TypeScript: Transpiled with `ts-loader` (transpileOnly: true for speed)
+- No type checking during test runs (done separately)
+
+## Karma Configuration
+
+**Special Features:**
+- Random test execution order (`jasmine.random: true`)
+- Stop on first failure (`stopSpecOnExpectationFailure: true`)
+- Custom reporters:
+  - `jasmine-seed` - Reports random seed for reproducibility
+  - `karma-skipped-failed` - Reports skipped/failed tests
+  - `karma-duplicate-test-name` - Detects duplicate test names
+- Extended timeouts for BrowserStack (60s)
+- Suppressed passed/skipped output (only shows failures)
+
+## Best Practices
+
+**Test Organization:**
+- Group tests logically with nested `describe()` blocks
+- Use descriptive test names that explain behavior
+- Keep tests focused on single behavior
+- Use `beforeEach()` for common setup
+
+**Assertions:**
+- Prefer specific matchers over generic ones
+- One logical assertion per test (can have multiple expect calls)
+- Use `jasmine.objectContaining()` for partial object matches
+- Use `jasmine.any(Type)` for type checking unknown values
+
+**Cleanup:**
+- Use `registerCleanupTask()` from test utilities for automatic cleanup
+- Unsubscribe from observables in tests
+- Clear timers and intervals
+- Reset spies if reused
+
+**Performance:**
+- Avoid unnecessary waits or delays
+- Mock time-dependent code with `mockClock()`
+- Keep tests fast (unit tests < 100ms each)
+- Use `transpileOnly: true` for faster TypeScript compilation
+
+---
+
+*Testing analysis: 2026-01-21*
diff --git a/.planning/plans/2026-02-25-browser-native-design.md b/.planning/plans/2026-02-25-browser-native-design.md
new file mode 100644
index 0000000000..0a63b5ac6f
--- /dev/null
+++ b/.planning/plans/2026-02-25-browser-native-design.md
@@ -0,0 +1,121 @@
+# Design: `@datadog/browser-native` package
+
+**Date:** 2026-02-25
+
+## Goal
+
+Create a new package that exposes all native browser API callsites used across the repository as a clean isolation layer between SDK code and the browser. The long-term goal is to reduce BrowserStack unit test scope to just this package — everything else can run in jsdom or headless Chrome.
+
+## Context
+
+The codebase already has `packages/core/src/browser/` with wrappers for fetch, XHR, cookies, event listeners, and observables. However, native browser API calls are scattered directly within that code with no formal seam for testing or isolation. This package establishes that seam.
+
+## Decisions
+
+| Question | Decision |
+|---|---|
+| Relationship to existing `core/src/browser/` | New layer — keep existing code, update callsites to import from the new package |
+| API style | Standalone function exports |
+| Function naming | Match browser API names where functions exist; getter/setter convention for properties |
+| Injection mechanism | Module-level (no mockable in v1 — added later) |
+| Initial scope | `packages/core/src/browser/` callsites only |
+| Mockability | Not in v1; the isolation boundary is established first |
+
+## Architecture
+
+New package at the base of the dependency graph — zero SDK dependencies.
+
+```
+@datadog/browser-native   ← new, zero SDK deps
+         ↓
+@datadog/browser-core
+         ↓
+@datadog/browser-rum-core, @datadog/browser-logs, ...
+```
+
+`@datadog/browser-core` adds `@datadog/browser-native` as a dependency.
+
+## Package location
+
+`packages/browser-native/` → published as `@datadog/browser-native`
+
+Follows the existing monorepo package structure:
+
+```
+packages/browser-native/
+├── src/
+│   ├── index.ts          # Re-exports everything
+│   ├── network.ts        # fetch, sendBeacon
+│   ├── events.ts         # addEventListener, removeEventListener
+│   ├── document.ts       # getCookie, setCookie, getReadyState, getVisibilityState
+│   └── performance.ts    # now
+├── package.json
+└── tsconfig.json
+```
+
+## Exports
+
+Standalone functions. Browser function names used directly; getter/setter convention for property accesses.
+
+```ts
+// Network
+export function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+export function sendBeacon(url: string, data?: BodyInit | null): boolean
+
+// Events
+export function addEventListener(
+  target: EventTarget,
+  type: string,
+  listener: EventListener,
+  options?: AddEventListenerOptions
+): void
+export function removeEventListener(
+  target: EventTarget,
+  type: string,
+  listener: EventListener,
+  options?: EventListenerOptions
+): void
+
+// Document properties
+export function getCookie(): string                     // wraps document.cookie getter
+export function setCookie(value: string): void          // wraps document.cookie setter
+export function getReadyState(): DocumentReadyState     // wraps document.readyState
+export function getVisibilityState(): VisibilityState   // wraps document.visibilityState
+
+// Performance
+export function now(): number                           // wraps performance.now()
+```
+
+### ZoneJS bypass
+
+`getZoneJsOriginalValue` moves from `packages/core/src/tools/` to `packages/browser-native/src/`. It has no SDK dependencies and is fundamentally about obtaining unpatched native values — it belongs in this layer. `fetch` and `addEventListener` use it internally.
+
+## Migration
+
+`packages/core/src/browser/` files are not restructured. Only their direct native callsites are updated to import from `@datadog/browser-native`:
+
+```ts
+// Before
+document.cookie = `${name}=${value};...`
+const value = document.cookie
+
+// After
+import { setCookie, getCookie } from '@datadog/browser-native'
+setCookie(`${name}=${value};...`)
+const value = getCookie()
+```
+
+All SDK logic — observables, monitoring, event trust filtering, the `addEventListener` wrapper — stays in `core/src/browser/` unchanged.
+
+## Testing
+
+`packages/browser-native` ships with its own unit tests co-located with source (`*.spec.ts`). These are the tests that require real browser APIs and are candidates for BrowserStack.
+
+Rerouting the BrowserStack scope (marking non-native tests as jsdom-only) is a **follow-up** outside v1 scope.
+
+## Out of scope for v1
+
+- `mockable()` wrapping on exported functions (added in a later phase once the boundary is proven)
+- Expanding scope beyond `packages/core/src/browser/` callsites
+- Rerouting BrowserStack test scope
+- Covering `packages/rum-core/src/browser/` callsites
diff --git a/.planning/plans/2026-02-25-browser-native-plan.md b/.planning/plans/2026-02-25-browser-native-plan.md
new file mode 100644
index 0000000000..c9f917276f
--- /dev/null
+++ b/.planning/plans/2026-02-25-browser-native-plan.md
@@ -0,0 +1,865 @@
+# `@datadog/browser-native` Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Create a new `packages/browser-native` package that wraps native browser API callsites from `packages/core/src/browser/` as standalone named functions, establishing an isolation layer between SDK code and the browser.
+
+**Architecture:** New zero-dependency package at the base of the dep graph. Each native API callsite becomes a standalone named export (matching browser API names where applicable, getter/setter convention for properties). `@datadog/browser-core` is updated to depend on this package and its `core/src/browser/` files import from it instead of calling native APIs directly.
+
+**Tech Stack:** TypeScript, Yarn workspaces v4, Karma/Jasmine for tests, same build tooling as other packages (`scripts/build/build-package.ts`).
+
+---
+
+### Task 1: Create the package scaffold
+
+**Files:**
+
+- Create: `packages/browser-native/package.json`
+- Create: `packages/browser-native/tsconfig.json`
+- Create: `packages/browser-native/src/index.ts`
+
+**Step 1: Create `packages/browser-native/package.json`**
+
+Model it on `packages/core/package.json`. No `dependencies` — this package is zero-dep.
+
+```json
+{
+  "name": "@datadog/browser-native",
+  "version": "6.27.1",
+  "license": "Apache-2.0",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "cjs/index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "node ../../scripts/build/build-package.ts --modules"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DataDog/browser-sdk.git",
+    "directory": "packages/browser-native"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
+```
+
+**Step 2: Create `packages/browser-native/tsconfig.json`**
+
+Model it on `packages/worker/tsconfig.json`.
+
+```json
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "declaration": true,
+    "rootDir": "./src/"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.spec.ts", "./src/**/*.specHelper.ts"]
+}
+```
+
+**Step 3: Create `packages/browser-native/src/index.ts`** (empty for now)
+
+```ts
+// exports added in later tasks
+```
+
+**Step 4: Commit**
+
+```bash
+git add packages/browser-native/
+git commit -m "✨ scaffold @datadog/browser-native package"
+```
+
+---
+
+### Task 2: Register package in the monorepo
+
+**Files:**
+
+- Modify: `tsconfig.base.json`
+
+**Step 1: Add the path alias to `tsconfig.base.json`**
+
+In the `paths` object, add:
+
+```json
+"@datadog/browser-native": ["./packages/browser-native/src"]
+```
+
+Add it as the first entry (it's the new base layer).
+
+**Step 2: Verify TypeScript resolves the new package**
+
+```bash
+yarn typecheck
+```
+
+Expected: no new errors (the package is empty so nothing to break yet).
+
+**Step 3: Commit**
+
+```bash
+git add tsconfig.base.json
+git commit -m "🔧 register @datadog/browser-native in tsconfig paths"
+```
+
+---
+
+### Task 3: Add internal utilities (ZoneJS bypass + global object)
+
+`browser-native` needs to bypass Zone.js (an Angular library that patches browser APIs). It cannot import this from `@datadog/browser-core` (that would create a circular dependency). Instead, it owns a minimal internal copy of these two utilities.
+
+**Files:**
+
+- Create: `packages/browser-native/src/globalObject.ts`
+- Create: `packages/browser-native/src/getZoneJsOriginalValue.ts`
+
+**Step 1: Create `packages/browser-native/src/globalObject.ts`**
+
+Copy the content of `packages/core/src/tools/globalObject.ts` verbatim. This file has no dependencies and is safe to replicate.
+
+```ts
+// Copy from packages/core/src/tools/globalObject.ts
+```
+
+**Step 2: Create `packages/browser-native/src/getZoneJsOriginalValue.ts`**
+
+Copy the content of `packages/core/src/tools/getZoneJsOriginalValue.ts` verbatim, but update the import to point to the local `globalObject`:
+
+```ts
+import { getGlobalObject } from './globalObject'
+
+// ... rest of the file identical to packages/core/src/tools/getZoneJsOriginalValue.ts
+```
+
+Do NOT export these files from `src/index.ts` — they are internal utilities only.
+
+**Step 3: Typecheck**
+
+```bash
+yarn typecheck
+```
+
+Expected: passes.
+
+**Step 4: Commit**
+
+```bash
+git add packages/browser-native/src/globalObject.ts packages/browser-native/src/getZoneJsOriginalValue.ts
+git commit -m "✨ add internal ZoneJS bypass utilities to browser-native"
+```
+
+---
+
+### Task 4: Implement network APIs
+
+**Files:**
+
+- Create: `packages/browser-native/src/network.ts`
+- Create: `packages/browser-native/src/network.spec.ts`
+
+**Step 1: Write the failing tests**
+
+```ts
+// packages/browser-native/src/network.spec.ts
+import { fetch, sendBeacon } from './network'
+
+describe('fetch', () => {
+  it('calls window.fetch with the given arguments', async () => {
+    const mockFetch = jasmine.createSpy().and.returnValue(Promise.resolve(new Response()))
+    spyOnProperty(window, 'fetch').and.returnValue(mockFetch)
+
+    await fetch('https://example.com', { method: 'POST' })
+
+    expect(mockFetch).toHaveBeenCalledWith('https://example.com', { method: 'POST' })
+  })
+})
+
+describe('sendBeacon', () => {
+  it('calls navigator.sendBeacon with the given arguments', () => {
+    spyOn(navigator, 'sendBeacon').and.returnValue(true)
+
+    const result = sendBeacon('https://example.com', 'data')
+
+    expect(navigator.sendBeacon).toHaveBeenCalledWith('https://example.com', 'data')
+    expect(result).toBeTrue()
+  })
+})
+```
+
+**Step 2: Run tests to verify they fail**
+
+```bash
+yarn test:unit --spec packages/browser-native/src/network.spec.ts
+```
+
+Expected: FAIL — `fetch` and `sendBeacon` not found.
+
+**Step 3: Implement `packages/browser-native/src/network.ts`**
+
+```ts
+import { getGlobalObject } from './globalObject'
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+
+/**
+ * Calls window.fetch, bypassing Zone.js patching if present.
+ * Zone.js (used by Angular) patches window.fetch which can cause issues
+ * like unnecessary change detection cycles. We use the original value.
+ */
+export function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+  return getZoneJsOriginalValue(getGlobalObject(), 'fetch')(input, init)
+}
+
+/**
+ * Calls navigator.sendBeacon.
+ */
+export function sendBeacon(url: string, data?: BodyInit | null): boolean {
+  return navigator.sendBeacon(url, data)
+}
+```
+
+**Step 4: Run tests to verify they pass**
+
+```bash
+yarn test:unit --spec packages/browser-native/src/network.spec.ts
+```
+
+Expected: PASS.
+
+**Step 5: Export from index.ts**
+
+```ts
+// packages/browser-native/src/index.ts
+export { fetch, sendBeacon } from './network'
+```
+
+**Step 6: Commit**
+
+```bash
+git add packages/browser-native/src/network.ts packages/browser-native/src/network.spec.ts packages/browser-native/src/index.ts
+git commit -m "✨ add fetch and sendBeacon to browser-native"
+```
+
+---
+
+### Task 5: Implement event listener APIs
+
+**Files:**
+
+- Create: `packages/browser-native/src/events.ts`
+- Create: `packages/browser-native/src/events.spec.ts`
+
+**Step 1: Write the failing tests**
+
+```ts
+// packages/browser-native/src/events.spec.ts
+import { addEventListener, removeEventListener } from './events'
+
+describe('addEventListener', () => {
+  it('adds an event listener to the target', () => {
+    const target = document.createElement('div')
+    const listener = jasmine.createSpy('listener')
+
+    addEventListener(target, 'click', listener)
+    target.dispatchEvent(new Event('click'))
+
+    expect(listener).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('removeEventListener', () => {
+  it('removes a previously added listener', () => {
+    const target = document.createElement('div')
+    const listener = jasmine.createSpy('listener')
+
+    addEventListener(target, 'click', listener)
+    removeEventListener(target, 'click', listener)
+    target.dispatchEvent(new Event('click'))
+
+    expect(listener).not.toHaveBeenCalled()
+  })
+})
+```
+
+**Step 2: Run tests to verify they fail**
+
+```bash
+yarn test:unit --spec packages/browser-native/src/events.spec.ts
+```
+
+Expected: FAIL.
+
+**Step 3: Implement `packages/browser-native/src/events.ts`**
+
+This replicates the core logic from `packages/core/src/browser/addEventListener.ts` lines 131–140 — using `EventTarget.prototype` when available (to avoid issues with frameworks like Salesforce LWC), and bypassing Zone.js.
+
+```ts
+import { getGlobalObject } from './globalObject'
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+
+type WindowWithEventTarget = Window & { EventTarget?: typeof EventTarget }
+
+function getListenerTarget(eventTarget: EventTarget): EventTarget {
+  const win = getGlobalObject<WindowWithEventTarget>()
+  return win.EventTarget && eventTarget instanceof EventTarget ? EventTarget.prototype : eventTarget
+}
+
+/**
+ * Adds an event listener to a target, bypassing Zone.js patching if present.
+ * Uses EventTarget.prototype when possible to avoid overrides in some frameworks.
+ */
+export function addEventListener(
+  target: EventTarget,
+  type: string,
+  listener: EventListenerOrEventListenerObject,
+  options?: boolean | AddEventListenerOptions
+): void {
+  const listenerTarget = getListenerTarget(target)
+  getZoneJsOriginalValue(listenerTarget, 'addEventListener').call(target, type, listener, options)
+}
+
+/**
+ * Removes an event listener from a target, bypassing Zone.js patching if present.
+ */
+export function removeEventListener(
+  target: EventTarget,
+  type: string,
+  listener: EventListenerOrEventListenerObject,
+  options?: boolean | EventListenerOptions
+): void {
+  const listenerTarget = getListenerTarget(target)
+  getZoneJsOriginalValue(listenerTarget, 'removeEventListener').call(target, type, listener, options)
+}
+```
+
+**Step 4: Run tests to verify they pass**
+
+```bash
+yarn test:unit --spec packages/browser-native/src/events.spec.ts
+```
+
+Expected: PASS.
+
+**Step 5: Export from index.ts**
+
+```ts
+export { fetch, sendBeacon } from './network'
+export { addEventListener, removeEventListener } from './events'
+```
+
+**Step 6: Commit**
+
+```bash
+git add packages/browser-native/src/events.ts packages/browser-native/src/events.spec.ts packages/browser-native/src/index.ts
+git commit -m "✨ add addEventListener and removeEventListener to browser-native"
+```
+
+---
+
+### Task 6: Implement document property wrappers
+
+**Files:**
+
+- Create: `packages/browser-native/src/document.ts`
+- Create: `packages/browser-native/src/document.spec.ts`
+
+**Step 1: Write the failing tests**
+
+```ts
+// packages/browser-native/src/document.spec.ts
+import { getCookie, setCookie, getReadyState, getVisibilityState } from './document'
+
+describe('getCookie', () => {
+  it('returns document.cookie', () => {
+    spyOnProperty(document, 'cookie', 'get').and.returnValue('foo=bar')
+    expect(getCookie()).toBe('foo=bar')
+  })
+})
+
+describe('setCookie', () => {
+  it('sets document.cookie', () => {
+    const spy = spyOnProperty(document, 'cookie', 'set')
+    setCookie('foo=bar; path=/')
+    expect(spy).toHaveBeenCalledWith('foo=bar; path=/')
+  })
+})
+
+describe('getReadyState', () => {
+  it('returns document.readyState', () => {
+    spyOnProperty(document, 'readyState', 'get').and.returnValue('complete')
+    expect(getReadyState()).toBe('complete')
+  })
+})
+
+describe('getVisibilityState', () => {
+  it('returns document.visibilityState', () => {
+    spyOnProperty(document, 'visibilityState', 'get').and.returnValue('hidden')
+    expect(getVisibilityState()).toBe('hidden')
+  })
+})
+```
+
+**Step 2: Run tests to verify they fail**
+
+```bash
+yarn test:unit --spec packages/browser-native/src/document.spec.ts
+```
+
+Expected: FAIL.
+
+**Step 3: Implement `packages/browser-native/src/document.ts`**
+
+```ts
+/** Returns the current value of document.cookie (all cookies as a single string). */
+export function getCookie(): string {
+  return document.cookie
+}
+
+/** Sets a cookie by assigning to document.cookie. */
+export function setCookie(value: string): void {
+  document.cookie = value
+}
+
+/** Returns document.readyState. */
+export function getReadyState(): DocumentReadyState {
+  return document.readyState
+}
+
+/** Returns document.visibilityState. */
+export function getVisibilityState(): DocumentVisibilityState {
+  return document.visibilityState
+}
+```
+
+**Step 4: Run tests to verify they pass**
+
+```bash
+yarn test:unit --spec packages/browser-native/src/document.spec.ts
+```
+
+Expected: PASS.
+
+**Step 5: Export from index.ts**
+
+```ts
+export { fetch, sendBeacon } from './network'
+export { addEventListener, removeEventListener } from './events'
+export { getCookie, setCookie, getReadyState, getVisibilityState } from './document'
+```
+
+**Step 6: Commit**
+
+```bash
+git add packages/browser-native/src/document.ts packages/browser-native/src/document.spec.ts packages/browser-native/src/index.ts
+git commit -m "✨ add document property wrappers to browser-native"
+```
+
+---
+
+### Task 7: Implement performance APIs
+
+**Files:**
+
+- Create: `packages/browser-native/src/performance.ts`
+- Create: `packages/browser-native/src/performance.spec.ts`
+
+**Step 1: Write the failing tests**
+
+```ts
+// packages/browser-native/src/performance.spec.ts
+import { now } from './performance'
+
+describe('now', () => {
+  it('returns performance.now()', () => {
+    spyOn(performance, 'now').and.returnValue(1234.5)
+    expect(now()).toBe(1234.5)
+  })
+})
+```
+
+**Step 2: Run tests to verify they fail**
+
+```bash
+yarn test:unit --spec packages/browser-native/src/performance.spec.ts
+```
+
+Expected: FAIL.
+
+**Step 3: Implement `packages/browser-native/src/performance.ts`**
+
+```ts
+/** Returns performance.now() — milliseconds elapsed since the navigation start, with sub-millisecond precision. */
+export function now(): number {
+  return performance.now()
+}
+```
+
+**Step 4: Run tests to verify they pass**
+
+```bash
+yarn test:unit --spec packages/browser-native/src/performance.spec.ts
+```
+
+Expected: PASS.
+
+**Step 5: Export from index.ts**
+
+```ts
+export { fetch, sendBeacon } from './network'
+export { addEventListener, removeEventListener } from './events'
+export { getCookie, setCookie, getReadyState, getVisibilityState } from './document'
+export { now } from './performance'
+```
+
+**Step 6: Commit**
+
+```bash
+git add packages/browser-native/src/performance.ts packages/browser-native/src/performance.spec.ts packages/browser-native/src/index.ts
+git commit -m "✨ add performance.now wrapper to browser-native"
+```
+
+---
+
+### Task 8: Wire up `@datadog/browser-core` dependency
+
+`@datadog/browser-core` needs to declare `@datadog/browser-native` as a dependency so it can import from it.
+
+**Files:**
+
+- Modify: `packages/core/package.json`
+
+**Step 1: Add the dependency**
+
+In `packages/core/package.json`, add a `dependencies` field (it currently has none):
+
+```json
+"dependencies": {
+  "@datadog/browser-native": "6.27.1"
+}
+```
+
+**Step 2: Install**
+
+```bash
+yarn install
+```
+
+**Step 3: Verify typecheck still passes**
+
+```bash
+yarn typecheck
+```
+
+Expected: PASS.
+
+**Step 4: Commit**
+
+```bash
+git add packages/core/package.json yarn.lock
+git commit -m "🔧 add @datadog/browser-native dependency to browser-core"
+```
+
+---
+
+### Task 9: Migrate `core/src/browser/fetch.ts`
+
+`packages/core/src/browser/fetch.ts` is a thin wrapper around the Zone.js-safe native fetch. After this task it simply re-exports from `browser-native`.
+
+**Files:**
+
+- Modify: `packages/core/src/browser/fetch.ts`
+
+**Step 1: Replace the implementation**
+
+The current file uses `getZoneJsOriginalValue(getGlobalObject(), 'fetch')`. Replace the entire file body with a re-export:
+
+```ts
+export { fetch } from '@datadog/browser-native'
+```
+
+**Step 2: Run the existing fetch tests**
+
+```bash
+yarn test:unit --spec packages/core/src/browser/fetch.spec.ts
+```
+
+Expected: PASS (same behavior, different source).
+
+**Step 3: Typecheck**
+
+```bash
+yarn typecheck
+```
+
+Expected: PASS.
+
+**Step 4: Commit**
+
+```bash
+git add packages/core/src/browser/fetch.ts
+git commit -m "♻️ migrate core/browser/fetch.ts to use @datadog/browser-native"
+```
+
+---
+
+### Task 10: Migrate `core/src/browser/cookie.ts`
+
+Replace direct `document.cookie` reads and writes with `getCookie()` and `setCookie()` from `browser-native`.
+
+**Files:**
+
+- Modify: `packages/core/src/browser/cookie.ts`
+
+**Step 1: Add the import**
+
+At the top of `cookie.ts`, add:
+
+```ts
+import { getCookie as getDocumentCookie, setCookie as setDocumentCookie } from '@datadog/browser-native'
+```
+
+(Aliased to avoid name collision with the existing `getCookie`/`setCookie` functions in this file.)
+
+**Step 2: Replace all `document.cookie` accesses**
+
+There are several in the file. Replace each one:
+
+- `document.cookie = ...` → `setDocumentCookie(...)`
+- `document.cookie` (reads) → `getDocumentCookie()`
+
+Use the file at `packages/core/src/browser/cookie.ts` as reference. The key occurrences are:
+
+- `setCookie()` function (line 26): `document.cookie = \`...\``→`setDocumentCookie(\`...\`)`
+- `getCookie()` function (line 34): `findCommaSeparatedValue(document.cookie, name)` → `findCommaSeparatedValue(getDocumentCookie(), name)`
+- `getCookies()` function (line 41): `findAllCommaSeparatedValues(document.cookie)` → `findAllCommaSeparatedValues(getDocumentCookie())`
+- `getInitCookie()` function (line 54): `findCommaSeparatedValues(document.cookie)` → `findCommaSeparatedValues(getDocumentCookie())`
+- `areCookiesAuthorized()` function (line 68): `document.cookie === undefined || document.cookie === null` → `getDocumentCookie() === undefined || getDocumentCookie() === null`
+
+**Step 3: Run the existing cookie tests**
+
+```bash
+yarn test:unit --spec packages/core/src/browser/cookie.spec.ts
+```
+
+Expected: PASS.
+
+**Step 4: Typecheck**
+
+```bash
+yarn typecheck
+```
+
+Expected: PASS.
+
+**Step 5: Commit**
+
+```bash
+git add packages/core/src/browser/cookie.ts
+git commit -m "♻️ migrate core/browser/cookie.ts to use @datadog/browser-native"
+```
+
+---
+
+### Task 11: Migrate `core/src/browser/addEventListener.ts`
+
+The `addEventListeners` function in this file calls the native `add`/`remove` methods via `getZoneJsOriginalValue`. Replace those two callsites with `addEventListener`/`removeEventListener` from `browser-native`.
+
+**Files:**
+
+- Modify: `packages/core/src/browser/addEventListener.ts`
+
+**Step 1: Add the import**
+
+```ts
+import {
+  addEventListener as nativeAddEventListener,
+  removeEventListener as nativeRemoveEventListener,
+} from '@datadog/browser-native'
+```
+
+**Step 2: Remove the lines that compute `listenerTarget`**
+
+Find and remove these lines (around line 128–135 in the current file):
+
+```ts
+const options = passive ? { capture, passive } : capture
+
+// Use the window.EventTarget.prototype when possible to avoid wrong overrides (e.g: https://github.com/salesforce/lwc/issues/1824)
+const listenerTarget =
+  window.EventTarget && eventTarget instanceof EventTarget ? window.EventTarget.prototype : eventTarget
+
+const add = getZoneJsOriginalValue(listenerTarget, 'addEventListener')
+eventNames.forEach((eventName) => add.call(eventTarget, eventName, listenerWithMonitor, options))
+```
+
+Replace with:
+
+```ts
+const options = passive ? { capture, passive } : capture
+
+eventNames.forEach((eventName) => nativeAddEventListener(eventTarget, eventName, listenerWithMonitor, options))
+```
+
+**Step 3: Update the `stop` function**
+
+Find (around line 137–140):
+
+```ts
+function stop() {
+  const remove = getZoneJsOriginalValue(listenerTarget, 'removeEventListener')
+  eventNames.forEach((eventName) => remove.call(eventTarget, eventName, listenerWithMonitor, options))
+}
+```
+
+Replace with:
+
+```ts
+function stop() {
+  eventNames.forEach((eventName) => nativeRemoveEventListener(eventTarget, eventName, listenerWithMonitor, options))
+}
+```
+
+**Step 4: Remove the now-unused import of `getZoneJsOriginalValue`** if it's no longer referenced in this file.
+
+**Step 5: Run the existing addEventListener tests**
+
+```bash
+yarn test:unit --spec packages/core/src/browser/addEventListener.spec.ts
+```
+
+Expected: PASS.
+
+**Step 6: Typecheck**
+
+```bash
+yarn typecheck
+```
+
+Expected: PASS.
+
+**Step 7: Commit**
+
+```bash
+git add packages/core/src/browser/addEventListener.ts
+git commit -m "♻️ migrate core/browser/addEventListener.ts to use @datadog/browser-native"
+```
+
+---
+
+### Task 12: Migrate remaining callsites in `core/src/browser/`
+
+**Files:**
+
+- Modify: `packages/core/src/browser/runOnReadyState.ts`
+- Modify: `packages/core/src/browser/pageMayExitObservable.ts`
+
+**Step 1: Migrate `runOnReadyState.ts`**
+
+Add import:
+
+```ts
+import { getReadyState } from '@datadog/browser-native'
+```
+
+Replace `document.readyState` (line 10):
+
+```ts
+// Before:
+if (document.readyState === expectedReadyState || document.readyState === 'complete') {
+// After:
+if (getReadyState() === expectedReadyState || getReadyState() === 'complete') {
+```
+
+**Step 2: Migrate `pageMayExitObservable.ts`**
+
+Add import:
+
+```ts
+import { getVisibilityState } from '@datadog/browser-native'
+```
+
+Replace `document.visibilityState` (line 31):
+
+```ts
+// Before:
+if (event.type === DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {
+// After:
+if (event.type === DOM_EVENT.VISIBILITY_CHANGE && getVisibilityState() === 'hidden') {
+```
+
+**Step 3: Run all core browser tests**
+
+```bash
+yarn test:unit --spec packages/core/src/browser/
+```
+
+Expected: PASS.
+
+**Step 4: Typecheck**
+
+```bash
+yarn typecheck
+```
+
+Expected: PASS.
+
+**Step 5: Commit**
+
+```bash
+git add packages/core/src/browser/runOnReadyState.ts packages/core/src/browser/pageMayExitObservable.ts
+git commit -m "♻️ migrate remaining core/browser/ callsites to @datadog/browser-native"
+```
+
+---
+
+### Task 13: Full test suite and lint
+
+Run the full test suite and lint to make sure nothing is broken.
+
+**Step 1: Run all unit tests**
+
+```bash
+yarn test:unit
+```
+
+Expected: PASS.
+
+**Step 2: Run typecheck**
+
+```bash
+yarn typecheck
+```
+
+Expected: PASS.
+
+**Step 3: Run lint**
+
+```bash
+yarn lint
+```
+
+Fix any lint issues.
+
+**Step 4: Commit any lint fixes**
+
+```bash
+git add -A
+git commit -m "🚨 fix lint issues after browser-native migration"
+```
+
+---
+
+## Out of scope
+
+- Adding `mockable()` wrapping to the exported functions (follow-up)
+- Expanding scope to `packages/rum-core/src/browser/` callsites (follow-up)
+- Rerouting BrowserStack test scope (follow-up)
+- Moving/unifying `getZoneJsOriginalValue` and `globalObject` from core to browser-native (follow-up)
diff --git a/eslint-local-rules/disallowSideEffects.js b/eslint-local-rules/disallowSideEffects.js
index d7bfb91f1f..faf83ef90d 100644
--- a/eslint-local-rules/disallowSideEffects.js
+++ b/eslint-local-rules/disallowSideEffects.js
@@ -36,6 +36,7 @@ const pathsWithSideEffect = new Set([
 const packagesWithoutSideEffect = new Set([
   '@datadog/browser-core',
   '@datadog/browser-rum-core',
+  '@datadog/browser-native',
   'react',
   'react-router-dom',
 ])
diff --git a/packages/browser-native/package.json b/packages/browser-native/package.json
new file mode 100644
index 0000000000..9982ee3de5
--- /dev/null
+++ b/packages/browser-native/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@datadog/browser-native",
+  "version": "6.27.1",
+  "license": "Apache-2.0",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "cjs/index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "node ../../scripts/build/build-package.ts --modules"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DataDog/browser-sdk.git",
+    "directory": "packages/browser-native"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/packages/browser-native/src/events.spec.ts b/packages/browser-native/src/events.spec.ts
new file mode 100644
index 0000000000..24e35b9bb9
--- /dev/null
+++ b/packages/browser-native/src/events.spec.ts
@@ -0,0 +1,115 @@
+import type { BrowserWindowWithZoneJs } from './getZoneJsOriginalValue'
+import { addEventListener, removeEventListener } from './events'
+
+describe('addEventListener', () => {
+  it('adds an event listener to the target', () => {
+    const target = document.createElement('div')
+    const listener = jasmine.createSpy('listener')
+
+    addEventListener(target, 'click', listener)
+    target.dispatchEvent(new Event('click'))
+
+    expect(listener).toHaveBeenCalledTimes(1)
+  })
+
+  it('forwards options to the native addEventListener', () => {
+    const target = document.createElement('div')
+    const listener = jasmine.createSpy('listener')
+    const options = { capture: true, once: true }
+
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalAdd = EventTarget.prototype.addEventListener
+    const addSpy = jasmine.createSpy('add').and.callFake(originalAdd.bind(target))
+    EventTarget.prototype.addEventListener = addSpy as any
+
+    try {
+      addEventListener(target, 'click', listener, options)
+      expect(addSpy).toHaveBeenCalledWith('click', listener, options)
+    } finally {
+      EventTarget.prototype.addEventListener = originalAdd
+    }
+  })
+
+  describe('Zone.js bypass', () => {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalAddEventListener = EventTarget.prototype.addEventListener
+
+    beforeEach(() => {
+      ;(window as BrowserWindowWithZoneJs).Zone = {
+        __symbol__: (name: string) => `__zone_symbol__${name}`,
+      }
+    })
+
+    afterEach(() => {
+      EventTarget.prototype.addEventListener = originalAddEventListener
+      delete (window as BrowserWindowWithZoneJs).Zone
+      delete (EventTarget.prototype as any).__zone_symbol__addEventListener
+    })
+
+    it('uses the Zone.js original addEventListener instead of the patched one', () => {
+      const target = document.createElement('div')
+      const listener = jasmine.createSpy('listener')
+
+      // Simulate Zone.js: patch the prototype and store original under the symbol key.
+      // We use direct assignment instead of spyOn to avoid breaking Karma's event tracking.
+      const patchedAddEventListener = jasmine.createSpy('patched addEventListener')
+      const zoneOriginalAddEventListener = jasmine.createSpy('zoneOriginalAddEventListener')
+
+      EventTarget.prototype.addEventListener = patchedAddEventListener as any
+      ;(EventTarget.prototype as any).__zone_symbol__addEventListener = zoneOriginalAddEventListener
+
+      addEventListener(target, 'click', listener)
+
+      expect(zoneOriginalAddEventListener).toHaveBeenCalledWith('click', listener, undefined)
+      expect(patchedAddEventListener).not.toHaveBeenCalled()
+    })
+  })
+})
+
+describe('removeEventListener', () => {
+  it('removes a previously added listener', () => {
+    const target = document.createElement('div')
+    const listener = jasmine.createSpy('listener')
+
+    addEventListener(target, 'click', listener)
+    removeEventListener(target, 'click', listener)
+    target.dispatchEvent(new Event('click'))
+
+    expect(listener).not.toHaveBeenCalled()
+  })
+
+  describe('Zone.js bypass', () => {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalRemoveEventListener = EventTarget.prototype.removeEventListener
+
+    beforeEach(() => {
+      ;(window as BrowserWindowWithZoneJs).Zone = {
+        __symbol__: (name: string) => `__zone_symbol__${name}`,
+      }
+    })
+
+    afterEach(() => {
+      EventTarget.prototype.removeEventListener = originalRemoveEventListener
+      delete (window as BrowserWindowWithZoneJs).Zone
+      delete (EventTarget.prototype as any).__zone_symbol__removeEventListener
+    })
+
+    it('uses the Zone.js original removeEventListener instead of the patched one', () => {
+      const target = document.createElement('div')
+      const listener = jasmine.createSpy('listener')
+
+      // Simulate Zone.js: patch the prototype and store original under the symbol key.
+      // We use direct assignment instead of spyOn to avoid breaking Karma's event tracking.
+      const patchedRemoveEventListener = jasmine.createSpy('patched removeEventListener')
+      const zoneOriginalRemoveEventListener = jasmine.createSpy('zoneOriginalRemoveEventListener')
+
+      EventTarget.prototype.removeEventListener = patchedRemoveEventListener as any
+      ;(EventTarget.prototype as any).__zone_symbol__removeEventListener = zoneOriginalRemoveEventListener
+
+      removeEventListener(target, 'click', listener)
+
+      expect(zoneOriginalRemoveEventListener).toHaveBeenCalledWith('click', listener, undefined)
+      expect(patchedRemoveEventListener).not.toHaveBeenCalled()
+    })
+  })
+})
diff --git a/packages/browser-native/src/events.ts b/packages/browser-native/src/events.ts
new file mode 100644
index 0000000000..dfdb4f1e6e
--- /dev/null
+++ b/packages/browser-native/src/events.ts
@@ -0,0 +1,36 @@
+import { getGlobalObject } from './globalObject'
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+
+type WindowWithEventTarget = Window & { EventTarget?: typeof EventTarget }
+
+function getListenerTarget(eventTarget: EventTarget): EventTarget {
+  const win = getGlobalObject<WindowWithEventTarget>()
+  return win.EventTarget && eventTarget instanceof EventTarget ? EventTarget.prototype : eventTarget
+}
+
+/**
+ * Adds an event listener to a target, bypassing Zone.js patching if present.
+ * Uses EventTarget.prototype when possible to avoid overrides in some frameworks.
+ */
+export function addEventListener(
+  target: EventTarget,
+  type: string,
+  listener: EventListenerOrEventListenerObject,
+  options?: boolean | AddEventListenerOptions
+): void {
+  const listenerTarget = getListenerTarget(target)
+  getZoneJsOriginalValue(listenerTarget, 'addEventListener').call(target, type, listener, options)
+}
+
+/**
+ * Removes an event listener from a target, bypassing Zone.js patching if present.
+ */
+export function removeEventListener(
+  target: EventTarget,
+  type: string,
+  listener: EventListenerOrEventListenerObject,
+  options?: boolean | EventListenerOptions
+): void {
+  const listenerTarget = getListenerTarget(target)
+  getZoneJsOriginalValue(listenerTarget, 'removeEventListener').call(target, type, listener, options)
+}
diff --git a/packages/browser-native/src/getZoneJsOriginalValue.ts b/packages/browser-native/src/getZoneJsOriginalValue.ts
new file mode 100644
index 0000000000..4be5b4ad82
--- /dev/null
+++ b/packages/browser-native/src/getZoneJsOriginalValue.ts
@@ -0,0 +1,38 @@
+import { getGlobalObject } from './globalObject'
+
+export interface BrowserWindowWithZoneJs extends Window {
+  Zone?: {
+    // All Zone.js versions expose the __symbol__ method, but we observed that some website have a
+    // 'Zone' global variable unrelated to Zone.js, so let's consider this method optional
+    // nonetheless.
+    __symbol__?: (name: string) => string
+  }
+}
+
+/**
+ * Gets the original value for a DOM API that was potentially patched by Zone.js.
+ *
+ * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original
+ * value of the patched functions/constructors/methods in a hidden property prefixed by
+ * __zone_symbol__.
+ *
+ * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to
+ * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to
+ * use the original DOM API instead of the one patched by Zone.js.
+ *
+ * [1]: https://github.com/angular/angular/tree/main/packages/zone.js
+ */
+export function getZoneJsOriginalValue<Target, Name extends keyof Target & string>(
+  target: Target,
+  name: Name
+): Target[Name] {
+  const browserWindow = getGlobalObject<BrowserWindowWithZoneJs>()
+  let original: Target[Name] | undefined
+  if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {
+    original = (target as any)[browserWindow.Zone.__symbol__(name)]
+  }
+  if (!original) {
+    original = target[name]
+  }
+  return original
+}
diff --git a/packages/browser-native/src/globalObject.ts b/packages/browser-native/src/globalObject.ts
new file mode 100644
index 0000000000..ce9b637c02
--- /dev/null
+++ b/packages/browser-native/src/globalObject.ts
@@ -0,0 +1,51 @@
+/**
+ * inspired by https://mathiasbynens.be/notes/globalthis
+ */
+
+// Extend/Create the WorkerGlobalScope interface to avoid issues when used in a non-browser tsconfig environment
+interface WorkerGlobalScope {
+  empty: never
+}
+
+// Utility type to enforce that exactly one of the two types is used
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }
+type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U
+
+export type GlobalObject = XOR<Window, WorkerGlobalScope>
+
+export function getGlobalObject<T = typeof globalThis>(): T {
+  if (typeof globalThis === 'object') {
+    return globalThis as unknown as T
+  }
+  Object.defineProperty(Object.prototype, '_dd_temp_', {
+    get() {
+      return this as object
+    },
+    configurable: true,
+  })
+  // @ts-ignore _dd_temp is defined using defineProperty
+  let globalObject: unknown = _dd_temp_
+  // @ts-ignore _dd_temp is defined using defineProperty
+  delete Object.prototype._dd_temp_
+  if (typeof globalObject !== 'object') {
+    // on safari _dd_temp_ is available on window but not globally
+    // fallback on other browser globals check
+    if (typeof self === 'object') {
+      globalObject = self
+    } else if (typeof window === 'object') {
+      globalObject = window
+    } else {
+      globalObject = {}
+    }
+  }
+  return globalObject as T
+}
+
+/**
+ * Cached reference to the global object so it can be imported and re-used without
+ * re-evaluating the heavyweight fallback logic in `getGlobalObject()`.
+ */
+// eslint-disable-next-line local-rules/disallow-side-effects
+export const globalObject = getGlobalObject<GlobalObject>()
+
+export const isWorkerEnvironment = 'WorkerGlobalScope' in globalObject
diff --git a/packages/browser-native/src/index.ts b/packages/browser-native/src/index.ts
new file mode 100644
index 0000000000..7617aead4e
--- /dev/null
+++ b/packages/browser-native/src/index.ts
@@ -0,0 +1,5 @@
+export { fetch, sendBeacon } from './transport'
+export { addEventListener, removeEventListener } from './events'
+export { getCookie, setCookie } from './storage'
+export { getReadyState, getVisibilityState } from './page'
+export { now } from './timing'
diff --git a/packages/browser-native/src/page.spec.ts b/packages/browser-native/src/page.spec.ts
new file mode 100644
index 0000000000..800eca3944
--- /dev/null
+++ b/packages/browser-native/src/page.spec.ts
@@ -0,0 +1,15 @@
+import { getReadyState, getVisibilityState } from './page'
+
+describe('getReadyState', () => {
+  it('returns document.readyState', () => {
+    spyOnProperty(document, 'readyState', 'get').and.returnValue('complete')
+    expect(getReadyState()).toBe('complete')
+  })
+})
+
+describe('getVisibilityState', () => {
+  it('returns document.visibilityState', () => {
+    spyOnProperty(document, 'visibilityState', 'get').and.returnValue('hidden')
+    expect(getVisibilityState()).toBe('hidden')
+  })
+})
diff --git a/packages/browser-native/src/page.ts b/packages/browser-native/src/page.ts
new file mode 100644
index 0000000000..483998695d
--- /dev/null
+++ b/packages/browser-native/src/page.ts
@@ -0,0 +1,9 @@
+/** Returns document.readyState. */
+export function getReadyState(): DocumentReadyState {
+  return document.readyState
+}
+
+/** Returns document.visibilityState. */
+export function getVisibilityState(): DocumentVisibilityState {
+  return document.visibilityState
+}
diff --git a/packages/browser-native/src/storage.spec.ts b/packages/browser-native/src/storage.spec.ts
new file mode 100644
index 0000000000..b209d0ba83
--- /dev/null
+++ b/packages/browser-native/src/storage.spec.ts
@@ -0,0 +1,16 @@
+import { getCookie, setCookie } from './storage'
+
+describe('getCookie', () => {
+  it('returns document.cookie', () => {
+    spyOnProperty(document, 'cookie', 'get').and.returnValue('foo=bar')
+    expect(getCookie()).toBe('foo=bar')
+  })
+})
+
+describe('setCookie', () => {
+  it('sets document.cookie', () => {
+    const spy = spyOnProperty(document, 'cookie', 'set')
+    setCookie('foo=bar; path=/')
+    expect(spy).toHaveBeenCalledWith('foo=bar; path=/')
+  })
+})
diff --git a/packages/browser-native/src/storage.ts b/packages/browser-native/src/storage.ts
new file mode 100644
index 0000000000..d57b9afa5f
--- /dev/null
+++ b/packages/browser-native/src/storage.ts
@@ -0,0 +1,9 @@
+/** Returns the current value of document.cookie (all cookies as a single string). */
+export function getCookie(): string {
+  return document.cookie
+}
+
+/** Sets a cookie by assigning to document.cookie. */
+export function setCookie(value: string): void {
+  document.cookie = value
+}
diff --git a/packages/browser-native/src/timing.spec.ts b/packages/browser-native/src/timing.spec.ts
new file mode 100644
index 0000000000..0fafae5567
--- /dev/null
+++ b/packages/browser-native/src/timing.spec.ts
@@ -0,0 +1,8 @@
+import { now } from './timing'
+
+describe('now', () => {
+  it('returns performance.now()', () => {
+    spyOn(performance, 'now').and.returnValue(1234.5)
+    expect(now()).toBe(1234.5)
+  })
+})
diff --git a/packages/browser-native/src/timing.ts b/packages/browser-native/src/timing.ts
new file mode 100644
index 0000000000..5c7a62c028
--- /dev/null
+++ b/packages/browser-native/src/timing.ts
@@ -0,0 +1,4 @@
+/** Returns performance.now() — milliseconds elapsed since the navigation start, with sub-millisecond precision. */
+export function now(): number {
+  return performance.now()
+}
diff --git a/packages/browser-native/src/transport.spec.ts b/packages/browser-native/src/transport.spec.ts
new file mode 100644
index 0000000000..69890fe4ab
--- /dev/null
+++ b/packages/browser-native/src/transport.spec.ts
@@ -0,0 +1,55 @@
+import type { BrowserWindowWithZoneJs } from './getZoneJsOriginalValue'
+import { fetch, sendBeacon } from './transport'
+
+describe('fetch', () => {
+  it('calls window.fetch with the given arguments and returns the response', async () => {
+    const mockResponse = new Response('test', { status: 200 })
+    spyOn(window, 'fetch').and.returnValue(Promise.resolve(mockResponse))
+
+    const result = await fetch('https://example.com', { method: 'POST' })
+
+    expect(window.fetch).toHaveBeenCalledWith('https://example.com', { method: 'POST' })
+    expect(result).toBe(mockResponse)
+  })
+
+  describe('Zone.js bypass', () => {
+    // Simulate Zone.js presence: Zone.js stores originals under __zone_symbol__<name>
+    // and exposes window.Zone.__symbol__ to build that key.
+    beforeEach(() => {
+      ;(window as BrowserWindowWithZoneJs).Zone = {
+        __symbol__: (name: string) => `__zone_symbol__${name}`,
+      }
+    })
+
+    afterEach(() => {
+      delete (window as BrowserWindowWithZoneJs).Zone
+      delete (window as any).__zone_symbol__fetch
+    })
+
+    it('uses the Zone.js original fetch instead of the patched window.fetch', async () => {
+      const nativeFetchSpy = spyOn(window, 'fetch')
+      const zoneOriginalFetch = jasmine.createSpy('zoneOriginalFetch').and.returnValue(Promise.resolve(new Response()))
+
+      // Zone.js replaces window.fetch with a patched version and stores the original
+      // under window.__zone_symbol__fetch
+      ;(window as any).__zone_symbol__fetch = zoneOriginalFetch
+
+      await fetch('https://example.com')
+
+      expect(zoneOriginalFetch).toHaveBeenCalled()
+      expect(nativeFetchSpy).not.toHaveBeenCalled()
+    })
+  })
+})
+
+describe('sendBeacon', () => {
+  it('calls navigator.sendBeacon with the given arguments', () => {
+    spyOn(navigator, 'sendBeacon').and.returnValue(true)
+
+    const result = sendBeacon('https://example.com', 'data')
+
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    expect(navigator.sendBeacon).toHaveBeenCalledWith('https://example.com', 'data')
+    expect(result).toBeTrue()
+  })
+})
diff --git a/packages/browser-native/src/transport.ts b/packages/browser-native/src/transport.ts
new file mode 100644
index 0000000000..ed51df81b4
--- /dev/null
+++ b/packages/browser-native/src/transport.ts
@@ -0,0 +1,18 @@
+import { getGlobalObject } from './globalObject'
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+
+/**
+ * Calls window.fetch, bypassing Zone.js patching if present.
+ * Zone.js (used by Angular) patches window.fetch which can cause issues
+ * like unnecessary change detection cycles. We use the original value.
+ */
+export function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+  return getZoneJsOriginalValue(getGlobalObject(), 'fetch')(input, init)
+}
+
+/**
+ * Calls navigator.sendBeacon.
+ */
+export function sendBeacon(url: string, data?: BodyInit | null): boolean {
+  return navigator.sendBeacon(url, data)
+}
diff --git a/packages/browser-native/tsconfig.json b/packages/browser-native/tsconfig.json
new file mode 100644
index 0000000000..57123a5cbe
--- /dev/null
+++ b/packages/browser-native/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "declaration": true,
+    "rootDir": "./src/"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.spec.ts", "./src/**/*.specHelper.ts"]
+}
diff --git a/packages/core/package.json b/packages/core/package.json
index 09b4a2e2a4..d086a4a685 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -14,6 +14,9 @@
     "url": "https://github.com/DataDog/browser-sdk.git",
     "directory": "packages/core"
   },
+  "dependencies": {
+    "@datadog/browser-native": "6.27.1"
+  },
   "devDependencies": {
     "@types/pako": "2.0.4",
     "pako": "2.1.0"
diff --git a/packages/core/src/browser/addEventListener.ts b/packages/core/src/browser/addEventListener.ts
index 6fb2c43ba5..ad0ab279e6 100644
--- a/packages/core/src/browser/addEventListener.ts
+++ b/packages/core/src/browser/addEventListener.ts
@@ -1,5 +1,8 @@
+import {
+  addEventListener as nativeAddEventListener,
+  removeEventListener as nativeRemoveEventListener,
+} from '@datadog/browser-native'
 import { monitor } from '../tools/monitor'
-import { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'
 import type { CookieStore, CookieStoreEventMap, VisualViewport, VisualViewportEventMap } from './browser.types'
 
 export type TrustableEvent<E extends Event = Event> = E & { __ddIsTrusted?: boolean }
@@ -127,16 +130,10 @@ export function addEventListeners<Target extends EventTarget, EventName extends
 
   const options = passive ? { capture, passive } : capture
 
-  // Use the window.EventTarget.prototype when possible to avoid wrong overrides (e.g: https://github.com/salesforce/lwc/issues/1824)
-  const listenerTarget =
-    window.EventTarget && eventTarget instanceof EventTarget ? window.EventTarget.prototype : eventTarget
-
-  const add = getZoneJsOriginalValue(listenerTarget, 'addEventListener')
-  eventNames.forEach((eventName) => add.call(eventTarget, eventName, listenerWithMonitor, options))
+  eventNames.forEach((eventName) => nativeAddEventListener(eventTarget, eventName, listenerWithMonitor, options))
 
   function stop() {
-    const remove = getZoneJsOriginalValue(listenerTarget, 'removeEventListener')
-    eventNames.forEach((eventName) => remove.call(eventTarget, eventName, listenerWithMonitor, options))
+    eventNames.forEach((eventName) => nativeRemoveEventListener(eventTarget, eventName, listenerWithMonitor, options))
   }
 
   return {
diff --git a/packages/core/src/browser/cookie.ts b/packages/core/src/browser/cookie.ts
index bab3f49e93..8ffe7e07f1 100644
--- a/packages/core/src/browser/cookie.ts
+++ b/packages/core/src/browser/cookie.ts
@@ -1,3 +1,4 @@
+import { getCookie as getDocumentCookie, setCookie as setDocumentCookie } from '@datadog/browser-native'
 import { display } from '../tools/display'
 import { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'
 import {
@@ -23,7 +24,7 @@ export function setCookie(name: string, value: string, expireDelay: number = 0,
   const domain = options && options.domain ? `;domain=${options.domain}` : ''
   const secure = options && options.secure ? ';secure' : ''
   const partitioned = options && options.partitioned ? ';partitioned' : ''
-  document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`
+  setDocumentCookie(`${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`)
 }
 
 /**
@@ -31,14 +32,14 @@ export function setCookie(name: string, value: string, expireDelay: number = 0,
  * If there are multiple cookies with the same name, returns the first one
  */
 export function getCookie(name: string) {
-  return findCommaSeparatedValue(document.cookie, name)
+  return findCommaSeparatedValue(getDocumentCookie(), name)
 }
 
 /**
  * Returns all the values of the cookies with the given name
  */
 export function getCookies(name: string): string[] {
-  return findAllCommaSeparatedValues(document.cookie).get(name) || []
+  return findAllCommaSeparatedValues(getDocumentCookie()).get(name) || []
 }
 
 let initCookieParsed: Map<string, string> | undefined
@@ -51,7 +52,7 @@ let initCookieParsed: Map<string, string> | undefined
  */
 export function getInitCookie(name: string) {
   if (!initCookieParsed) {
-    initCookieParsed = findCommaSeparatedValues(document.cookie)
+    initCookieParsed = findCommaSeparatedValues(getDocumentCookie())
   }
   return initCookieParsed.get(name)
 }
@@ -65,7 +66,7 @@ export function deleteCookie(name: string, options?: CookieOptions) {
 }
 
 export function areCookiesAuthorized(options: CookieOptions): boolean {
-  if (document.cookie === undefined || document.cookie === null) {
+  if (getDocumentCookie() === undefined || getDocumentCookie() === null) {
     return false
   }
   try {
diff --git a/packages/core/src/browser/fetch.ts b/packages/core/src/browser/fetch.ts
index 574f44fd13..6bf016f198 100644
--- a/packages/core/src/browser/fetch.ts
+++ b/packages/core/src/browser/fetch.ts
@@ -1,14 +1 @@
-import { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'
-import { getGlobalObject } from '../tools/globalObject'
-
-/**
- * Make a fetch request using the native implementation, bypassing Zone.js patching.
- * This prevents unnecessary Angular change detection cycles.
- *
- * @param input - The resource to fetch (URL or Request object)
- * @param init - Optional fetch options
- * @returns A Promise that resolves to the Response
- */
-export function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-  return getZoneJsOriginalValue(getGlobalObject(), 'fetch')(input, init)
-}
+export { fetch } from '@datadog/browser-native'
diff --git a/packages/core/src/browser/pageMayExitObservable.ts b/packages/core/src/browser/pageMayExitObservable.ts
index 8808db3d4e..818d6d6b21 100644
--- a/packages/core/src/browser/pageMayExitObservable.ts
+++ b/packages/core/src/browser/pageMayExitObservable.ts
@@ -1,3 +1,4 @@
+import { getVisibilityState } from '@datadog/browser-native'
 import { Observable } from '../tools/observable'
 import { objectValues } from '../tools/utils/polyfills'
 import type { Configuration } from '../domain/configuration'
@@ -28,7 +29,7 @@ export function createPageMayExitObservable(configuration: Configuration): Obser
       window,
       [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE],
       (event) => {
-        if (event.type === DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {
+        if (event.type === DOM_EVENT.VISIBILITY_CHANGE && getVisibilityState() === 'hidden') {
           /**
            * Only event that guarantee to fire on mobile devices when the page transitions to background state
            * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
diff --git a/packages/core/src/browser/runOnReadyState.ts b/packages/core/src/browser/runOnReadyState.ts
index bbc2740068..71c726ec06 100644
--- a/packages/core/src/browser/runOnReadyState.ts
+++ b/packages/core/src/browser/runOnReadyState.ts
@@ -1,3 +1,4 @@
+import { getReadyState } from '@datadog/browser-native'
 import type { Configuration } from '../domain/configuration'
 import { noop } from '../tools/utils/functionUtils'
 import { DOM_EVENT, addEventListener } from './addEventListener'
@@ -7,7 +8,7 @@ export function runOnReadyState(
   expectedReadyState: 'complete' | 'interactive',
   callback: () => void
 ): { stop: () => void } {
-  if (document.readyState === expectedReadyState || document.readyState === 'complete') {
+  if (getReadyState() === expectedReadyState || getReadyState() === 'complete') {
     callback()
     return { stop: noop }
   }
diff --git a/tsconfig.base.json b/tsconfig.base.json
index c40d33dd99..d1583b1fd1 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -17,6 +17,8 @@
     "lib": ["ES2020", "DOM", "WebWorker"],
 
     "paths": {
+      "@datadog/browser-native": ["./packages/browser-native/src"],
+
       "@datadog/browser-core": ["./packages/core/src"],
 
       "@datadog/browser-flagging": ["./packages/flagging/src/entries/main"],
diff --git a/yarn.lock b/yarn.lock
index 6c5aa88a58..8781c2fbb6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -281,6 +281,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@datadog/browser-core@workspace:packages/core"
   dependencies:
+    "@datadog/browser-native": "npm:6.27.1"
     "@types/pako": "npm:2.0.4"
     pako: "npm:2.1.0"
   languageName: unknown
@@ -313,6 +314,12 @@ __metadata:
   languageName: unknown
   linkType: soft
 
+"@datadog/browser-native@npm:6.27.1, @datadog/browser-native@workspace:packages/browser-native":
+  version: 0.0.0-use.local
+  resolution: "@datadog/browser-native@workspace:packages/browser-native"
+  languageName: unknown
+  linkType: soft
+
 "@datadog/browser-rum-core@npm:6.27.1, @datadog/browser-rum-core@workspace:packages/rum-core":
   version: 0.0.0-use.local
   resolution: "@datadog/browser-rum-core@workspace:packages/rum-core"