From ded4f368346d988529e99ce4a84abe4ef0f755d8 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Wed, 5 Aug 2026 14:13:57 +0200
Subject: [PATCH 1/6] fix(core): Account for clock drift on every
 `timestampInSeconds` call

---
 packages/core/src/utils/time.ts           |  52 +++++--
 packages/core/test/lib/utils/time.test.ts | 173 +++++++++++++++++++++-
 2 files changed, 208 insertions(+), 17 deletions(-)

diff --git a/packages/core/src/utils/time.ts b/packages/core/src/utils/time.ts
index b736f546c9c5..00283bc6e48f 100644
--- a/packages/core/src/utils/time.ts
+++ b/packages/core/src/utils/time.ts
@@ -3,6 +3,12 @@ import { GLOBAL_OBJ } from './worldwide';
 
 const ONE_SECOND_IN_MS = 1000;
 
+/**
+ * Maximum tolerated difference between the monotonic clock and the wall clock before we consider
+ * the monotonic clock's time origin stale.
+ */
+const CLOCK_DRIFT_THRESHOLD_MS = 300_000; // 5 minutes in milliseconds
+
 /**
  * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
  * for accessing a high-resolution monotonic clock.
@@ -39,19 +45,32 @@ function createUnixTimestampInSecondsFunc(): () => number {
     return dateTimestampInSeconds;
   }
 
-  const timeOrigin = performance.timeOrigin;
-
   // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current
   // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.
-  //
-  // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the
-  // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and
-  // correct for this.
-  // See: https://github.com/getsentry/sentry-javascript/issues/2590
-  // See: https://github.com/mdn/content/issues/4713
-  // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6
+  let timeOrigin = performance.timeOrigin;
+
   return () => {
-    return (timeOrigin + withRandomSafeContext(() => performance.now())) / ONE_SECOND_IN_MS;
+    return withRandomSafeContext(() => {
+      const performanceNow = performance.now();
+      const dateNow = Date.now();
+
+      // `timeOrigin + performance.now()` only equals wall clock time for as long as both clocks advance in lockstep.
+      // performance.now() stops advancing while the device is asleep, so it under-counts elapsed wall time; conversely
+      // the wall clock itself can be stepped by Network Time Protocol (NTP) or the user. Either way the two drift apart
+      // by arbitrary amounts. Re-deriving the origin restores absolute accuracy while still taking elapsed time from
+      // the monotonic clock, so durations keep sub-millisecond precision and cannot run backwards.
+      // Timestamps taken before a correction are measured against a different origin than those taken after it, so a
+      // span that starts before one and ends after it absorbs the drift into its duration. Spans that lie entirely on
+      // one side of a correction are unaffected.
+      // See: https://github.com/getsentry/sentry-javascript/issues/2590
+      // See: https://github.com/mdn/content/issues/4713
+      // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6
+      if (Math.abs(timeOrigin + performanceNow - dateNow) > CLOCK_DRIFT_THRESHOLD_MS) {
+        timeOrigin = dateNow - performanceNow;
+      }
+
+      return (timeOrigin + performanceNow) / ONE_SECOND_IN_MS;
+    });
   };
 }
 
@@ -61,10 +80,12 @@ let _cachedTimestampInSeconds: (() => number) | undefined;
  * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
  * availability of the Performance API.
  *
- * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
- * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
- * skew can grow to arbitrary amounts like days, weeks or months.
- * See https://github.com/getsentry/sentry-javascript/issues/2590.
+ * Because the Performance API's clock and the wall clock can drift apart (the former stops while the computer is
+ * asleep, the latter can be stepped by NTP or the user), the time origin they are combined against is re-derived from
+ * `Date.now()` whenever the two disagree by more than {@link CLOCK_DRIFT_THRESHOLD_MS}. Two timestamps taken on either
+ * side of such a correction are skewed relative to each other by the amount of drift, so a span that starts before a
+ * correction and ends after it reports the wall clock time elapsed rather than the time the monotonic clock was
+ * running. See https://github.com/getsentry/sentry-javascript/issues/2590.
  */
 export function timestampInSeconds(): number {
   // We store this in a closure so that we don't have to create a new function every time this is called.
@@ -92,14 +113,13 @@ function getBrowserTimeOrigin(): number | undefined {
     return undefined;
   }
 
-  const threshold = 300_000; // 5 minutes in milliseconds
   const performanceNow = withRandomSafeContext(() => performance.now());
   const dateNow = safeDateNow();
 
   const timeOrigin = performance.timeOrigin;
   if (typeof timeOrigin === 'number') {
     const timeOriginDelta = Math.abs(timeOrigin + performanceNow - dateNow);
-    if (timeOriginDelta < threshold) {
+    if (timeOriginDelta < CLOCK_DRIFT_THRESHOLD_MS) {
       return timeOrigin;
     }
   }
diff --git a/packages/core/test/lib/utils/time.test.ts b/packages/core/test/lib/utils/time.test.ts
index 50ae3641701f..70fc7e5c0243 100644
--- a/packages/core/test/lib/utils/time.test.ts
+++ b/packages/core/test/lib/utils/time.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 async function getFreshPerformanceTimeOrigin() {
   // Adding the query param with the date, forces a fresh import each time this is called
@@ -7,8 +7,179 @@ async function getFreshPerformanceTimeOrigin() {
   return timeModule.browserPerformanceTimeOrigin();
 }
 
+let freshImportCounter = 0;
+
+async function getFreshTimestampInSeconds(): Promise<() => number> {
+  // A counter rather than `Date.now()`: these tests run under fake timers, which freeze the wall clock and would
+  // otherwise hand out a cached module.
+  const timeModule = await import(`../../../src/utils/time?update=${freshImportCounter++}`);
+  return timeModule.timestampInSeconds;
+}
+
 const RELIABLE_THRESHOLD_MS = 300_000;
 
+describe('timestampInSeconds', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('derives the timestamp from `performance.timeOrigin` and `performance.now()`', async () => {
+    const currentTimeMs = 1767778040866;
+    const timeSincePageloadMs = 1_234.56789;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    expect(timestampInSeconds()).toBe(currentTimeMs / 1000);
+  });
+
+  it('falls back to `Date.now()` if the performance API is unavailable', async () => {
+    const currentTimeMs = 1767778040866;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', undefined);
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    expect(timestampInSeconds()).toBe(currentTimeMs / 1000);
+  });
+
+  it('keeps using `performance.timeOrigin` while the clocks agree', async () => {
+    const currentTimeMs = 1767778040866;
+    // Below the drift threshold, so the (inaccurate) time origin must be preserved.
+    const timeOriginSkewMs = RELIABLE_THRESHOLD_MS - 2_000;
+
+    let timeSincePageloadMs = 1_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs + timeOriginSkewMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    expect(timestampInSeconds()).toBe((currentTimeMs + timeOriginSkewMs) / 1000);
+
+    timeSincePageloadMs = 5_000;
+    vi.setSystemTime(new Date(currentTimeMs + 4_000));
+
+    expect(timestampInSeconds()).toBe((currentTimeMs + 4_000 + timeOriginSkewMs) / 1000);
+  });
+
+  it('re-derives the time origin once the monotonic clock drifts from the wall clock', async () => {
+    const currentTimeMs = 1767778040866;
+    const timeSincePageloadMs = 1_000;
+
+    // The monotonic clock pauses during sleep, so the wall clock advances much further than it does.
+    const sleepDurationMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    expect(timestampInSeconds()).toBe(currentTimeMs / 1000);
+
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+
+    expect(timestampInSeconds()).toBe((currentTimeMs + sleepDurationMs) / 1000);
+  });
+
+  it('keeps deriving elapsed time from the monotonic clock after re-deriving the time origin', async () => {
+    const currentTimeMs = 1767778040866;
+    const sleepDurationMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+    let timeSincePageloadMs = 1_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    timestampInSeconds();
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    const afterCorrection = timestampInSeconds();
+
+    // `Date.now()` deliberately stays put while the monotonic clock advances sub-millisecond, proving the elapsed
+    // time comes from `performance.now()` rather than from the coarser wall clock.
+    timeSincePageloadMs += 0.25;
+    expect(timestampInSeconds()).toBeCloseTo(afterCorrection + 0.25 / 1000, 10);
+  });
+
+  it('does not re-derive the time origin repeatedly once the clocks agree again', async () => {
+    const currentTimeMs = 1767778040866;
+    const sleepDurationMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+    let timeSincePageloadMs = 1_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    timestampInSeconds();
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    timestampInSeconds();
+
+    // Advance both clocks in lockstep: the re-derived time origin must stay valid, so timestamps track the wall clock
+    // exactly rather than oscillating between the two sources.
+    for (let i = 1; i <= 3; i++) {
+      timeSincePageloadMs += 1_000;
+      vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs + i * 1_000));
+      expect(timestampInSeconds()).toBe((currentTimeMs + sleepDurationMs + i * 1_000) / 1000);
+    }
+  });
+
+  it('produces monotonically increasing timestamps when the wall clock steps backwards', async () => {
+    const currentTimeMs = 1767778040866;
+
+    let timeSincePageloadMs = 1_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    const before = timestampInSeconds();
+
+    // A backwards wall clock step (NTP correction, user changing the clock) beyond the threshold.
+    vi.setSystemTime(new Date(currentTimeMs - RELIABLE_THRESHOLD_MS - 60_000));
+    timeSincePageloadMs += 1_000;
+    const afterStep = timestampInSeconds();
+
+    // The correction itself moves the timestamp backwards, but elapsed time afterwards is still monotonic.
+    timeSincePageloadMs += 1_000;
+    expect(timestampInSeconds()).toBeGreaterThan(afterStep);
+    expect(before).toBeGreaterThan(afterStep);
+  });
+});
+
 describe('browserPerformanceTimeOrigin', () => {
   it('returns `performance.timeOrigin` if it is available and reliable', async () => {
     const timeOrigin = await getFreshPerformanceTimeOrigin();

From 793d21cafa80c83bed7597196ceebcc84f9688e8 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Fri, 7 Aug 2026 14:53:08 +0200
Subject: [PATCH 2/6] fix(core): Resolve monotonic times against the origin
 they were measured with
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`timestampInSeconds` re-derives its time origin when it detects clock drift, so
a single origin is only valid for part of a page's lifetime. Consumers that
convert a `PerformanceEntry`'s monotonic `startTime` to wall clock time have no
way to know which one applied to a given entry, and `browserPerformanceTimeOrigin`
caches the origin resolved at SDK init and never revisits it.

Adds `performanceTimeToSeconds`, which keeps the superseded origins around and
picks the one that was in effect when the passed time was measured. Entries
reported long after the fact — INP on pagehide, replay entries buffered until
flush — therefore stay on the timeline they were recorded on instead of being
retroactively shifted by a drift that happened afterwards.

The correction boundary is the `performance.now()` value the drift was detected
at, which is an upper bound on where it actually happened; that is as close as
it can be pinned down without a second clock.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 packages/core/src/index.ts                |   7 +-
 packages/core/src/utils/time.ts           |  73 +++++++++++
 packages/core/test/lib/utils/time.test.ts | 146 +++++++++++++++++++++-
 3 files changed, 222 insertions(+), 4 deletions(-)

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 20b52be30603..5e4da3058682 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -276,7 +276,12 @@ export {
   supportsReferrerPolicy,
 } from './utils/supports';
 export { SyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './utils/syncpromise';
-export { browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds } from './utils/time';
+export {
+  browserPerformanceTimeOrigin,
+  dateTimestampInSeconds,
+  performanceTimeToSeconds,
+  timestampInSeconds,
+} from './utils/time';
 export {
   TRACEPARENT_REGEXP,
   extractTraceparentData,
diff --git a/packages/core/src/utils/time.ts b/packages/core/src/utils/time.ts
index 00283bc6e48f..076e6d408422 100644
--- a/packages/core/src/utils/time.ts
+++ b/packages/core/src/utils/time.ts
@@ -9,6 +9,14 @@ const ONE_SECOND_IN_MS = 1000;
  */
 const CLOCK_DRIFT_THRESHOLD_MS = 300_000; // 5 minutes in milliseconds
 
+/**
+ * Upper bound on the number of drift corrections {@link performanceTimeToSeconds} remembers. A page has to survive that
+ * many separate clock jumps to reach it, so the cap only keeps a pathological clock from growing the list without
+ * bound. Once reached, the oldest segments are merged away, which at worst makes the very earliest monotonic
+ * timestamps convert against a later origin — the same result as not tracking segments at all.
+ */
+const MAX_TIME_ORIGIN_SEGMENTS = 30;
+
 /**
  * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
  * for accessing a high-resolution monotonic clock.
@@ -31,6 +39,27 @@ export function dateTimestampInSeconds(): number {
   return safeDateNow() / ONE_SECOND_IN_MS;
 }
 
+/**
+ * A stretch of the monotonic clock's timeline and the wall clock time its zero maps to.
+ *
+ * The monotonic→wall mapping is piecewise: a drift correction replaces the origin from that point on, but leaves the
+ * mapping for everything that came before it intact. Keeping the superseded origins around lets a monotonic timestamp
+ * be converted against the origin that was in effect when the timestamp was taken, rather than the one in effect when
+ * the conversion happens to run.
+ */
+interface TimeOriginSegment {
+  /** The `performance.now()` value from which `origin` applies. */
+  from: number;
+  /** Milliseconds since the UNIX epoch that `performance.now() === 0` corresponds to. */
+  origin: number;
+}
+
+/**
+ * Time origins in effect over the lifetime of the page, oldest first. Empty until the first `timestampInSeconds` call,
+ * and whenever the Performance API is unavailable.
+ */
+let _timeOriginSegments: TimeOriginSegment[] = [];
+
 /**
  * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
  * support the API.
@@ -48,6 +77,8 @@ function createUnixTimestampInSecondsFunc(): () => number {
   // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current
   // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.
   let timeOrigin = performance.timeOrigin;
+  _timeOriginSegments = [{ from: 0, origin: timeOrigin }];
+  let isFirstCall = true;
 
   return () => {
     return withRandomSafeContext(() => {
@@ -67,7 +98,20 @@ function createUnixTimestampInSecondsFunc(): () => number {
       // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6
       if (Math.abs(timeOrigin + performanceNow - dateNow) > CLOCK_DRIFT_THRESHOLD_MS) {
         timeOrigin = dateNow - performanceNow;
+        // The very first check runs before any timestamp has been handed out, so a `performance.timeOrigin` that was
+        // already unreliable at startup never applied to anything and is replaced outright. Later corrections only
+        // apply from the point they are detected at — an upper bound on where the drift actually happened, and as
+        // close as it can be pinned down without a second clock. Timestamps taken before that keep their old origin.
+        if (isFirstCall) {
+          _timeOriginSegments = [{ from: 0, origin: timeOrigin }];
+        } else {
+          _timeOriginSegments.push({ from: performanceNow, origin: timeOrigin });
+          if (_timeOriginSegments.length > MAX_TIME_ORIGIN_SEGMENTS) {
+            _timeOriginSegments.shift();
+          }
+        }
       }
+      isFirstCall = false;
 
       return (timeOrigin + performanceNow) / ONE_SECOND_IN_MS;
     });
@@ -76,6 +120,35 @@ function createUnixTimestampInSecondsFunc(): () => number {
 
 let _cachedTimestampInSeconds: (() => number) | undefined;
 
+/**
+ * Converts a monotonic time from the Performance API (a `PerformanceEntry`'s `startTime`, a profiler sample's
+ * `timestamp`, or any other `performance.now()`-relative value in milliseconds) to a wall clock timestamp in seconds
+ * since the UNIX epoch, on the same timeline as {@link timestampInSeconds}.
+ *
+ * Prefer this over combining a monotonic time with {@link browserPerformanceTimeOrigin} by hand: because the SDK
+ * re-derives its time origin when the monotonic and wall clocks drift apart, a single origin is only valid for part of
+ * the page's lifetime. This picks the origin that was in effect when the passed time was measured, so entries reported
+ * long after the fact (INP on pagehide, replay entries buffered until flush) do not get retroactively shifted by a
+ * drift that happened after they were recorded.
+ *
+ * Returns `undefined` if the Performance API is unavailable, in which case monotonic times cannot be converted at all.
+ */
+export function performanceTimeToSeconds(monotonicTimeInMs: number): number | undefined {
+  // Segments are only populated once `timestampInSeconds` has resolved which clock source to use.
+  timestampInSeconds();
+
+  let segment: TimeOriginSegment | undefined;
+  for (const candidate of _timeOriginSegments) {
+    // Times preceding the oldest retained segment fall back to it, which is the best guess available for them.
+    if (segment && candidate.from > monotonicTimeInMs) {
+      break;
+    }
+    segment = candidate;
+  }
+
+  return segment && (segment.origin + monotonicTimeInMs) / ONE_SECOND_IN_MS;
+}
+
 /**
  * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
  * availability of the Performance API.
diff --git a/packages/core/test/lib/utils/time.test.ts b/packages/core/test/lib/utils/time.test.ts
index 70fc7e5c0243..c1999fdf2dd0 100644
--- a/packages/core/test/lib/utils/time.test.ts
+++ b/packages/core/test/lib/utils/time.test.ts
@@ -9,11 +9,17 @@ async function getFreshPerformanceTimeOrigin() {
 
 let freshImportCounter = 0;
 
-async function getFreshTimestampInSeconds(): Promise<() => number> {
+async function getFreshTimeModule(): Promise<{
+  timestampInSeconds: () => number;
+  performanceTimeToSeconds: (monotonicTimeInMs: number) => number | undefined;
+}> {
   // A counter rather than `Date.now()`: these tests run under fake timers, which freeze the wall clock and would
   // otherwise hand out a cached module.
-  const timeModule = await import(`../../../src/utils/time?update=${freshImportCounter++}`);
-  return timeModule.timestampInSeconds;
+  return import(`../../../src/utils/time?update=${freshImportCounter++}`);
+}
+
+async function getFreshTimestampInSeconds(): Promise<() => number> {
+  return (await getFreshTimeModule()).timestampInSeconds;
 }
 
 const RELIABLE_THRESHOLD_MS = 300_000;
@@ -180,6 +186,140 @@ describe('timestampInSeconds', () => {
   });
 });
 
+describe('performanceTimeToSeconds', () => {
+  const currentTimeMs = 1767778040866;
+  const timeSincePageloadMs = 1_000;
+  const sleepDurationMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('converts against `performance.timeOrigin` while the clocks agree', async () => {
+    const timeOrigin = currentTimeMs - timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', { timeOrigin, now: () => timeSincePageloadMs });
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(500)).toBe((timeOrigin + 500) / 1000);
+  });
+
+  it('converts a time taken after a correction against the corrected origin', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      // The monotonic clock pauses during sleep, so it barely advances while the wall clock jumps ahead.
+      now: () => timeSincePageloadMs,
+    });
+
+    const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
+
+    timestampInSeconds();
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+
+    // Converting the current `performance.now()` must yield the same wall clock time that `timestampInSeconds`
+    // reports, otherwise perf entries and spans land on diverging timelines.
+    expect(performanceTimeToSeconds(timeSincePageloadMs)).toBe(timestampInSeconds());
+    expect(performanceTimeToSeconds(timeSincePageloadMs)).toBe((currentTimeMs + sleepDurationMs) / 1000);
+  });
+
+  it('keeps converting a time taken before a correction against the origin that was in effect then', async () => {
+    let monotonicNowMs = timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => monotonicNowMs,
+    });
+
+    const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
+
+    // An entry observed before the drift. Its wall clock time is known exactly at this point.
+    const entryStartTime = 500;
+    const entryTimestampBefore = performanceTimeToSeconds(entryStartTime);
+    expect(entryTimestampBefore).toBe((currentTimeMs - timeSincePageloadMs + entryStartTime) / 1000);
+
+    // The device sleeps, the drift is detected, and the origin is re-derived.
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    monotonicNowMs += 10;
+    timestampInSeconds();
+
+    // Converting the same entry now must not retroactively shift it by the drift.
+    expect(performanceTimeToSeconds(entryStartTime)).toBe(entryTimestampBefore);
+  });
+
+  it('converts times on either side of a correction against their respective origins', async () => {
+    let monotonicNowMs = timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => monotonicNowMs,
+    });
+
+    const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
+
+    timestampInSeconds();
+
+    const monotonicAdvanceMs = 10;
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    const correctionPointMs = (monotonicNowMs += monotonicAdvanceMs);
+    timestampInSeconds();
+
+    const beforeCorrection = performanceTimeToSeconds(correctionPointMs - 1) as number;
+    const afterCorrection = performanceTimeToSeconds(correctionPointMs + 1) as number;
+
+    // The two are 2ms apart on the monotonic clock, but the origins they resolve to are a whole sleep apart: the wall
+    // clock advanced `sleepDurationMs` while the monotonic clock only advanced `monotonicAdvanceMs`.
+    const driftMs = sleepDurationMs - monotonicAdvanceMs;
+    expect(afterCorrection - beforeCorrection).toBeCloseTo((driftMs + 2) / 1000, 6);
+  });
+
+  it('converts times preceding the oldest known origin against that origin', async () => {
+    const timeOrigin = currentTimeMs - timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', { timeOrigin, now: () => timeSincePageloadMs });
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(0)).toBe(timeOrigin / 1000);
+  });
+
+  it('never converts against a `performance.timeOrigin` that was already unreliable at startup', async () => {
+    // Some browsers report a bogus `performance.timeOrigin`. It never described a real point in time, so no monotonic
+    // time should ever be converted against it — not even one measured before the SDK first looked at the clock.
+    const timeOriginSkewMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs + timeOriginSkewMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(0)).toBe((currentTimeMs - timeSincePageloadMs) / 1000);
+  });
+
+  it('returns `undefined` if the performance API is unavailable', async () => {
+    vi.stubGlobal('performance', undefined);
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(500)).toBeUndefined();
+  });
+});
+
 describe('browserPerformanceTimeOrigin', () => {
   it('returns `performance.timeOrigin` if it is available and reliable', async () => {
     const timeOrigin = await getFreshPerformanceTimeOrigin();

From 1a9120efd1128b32651bf0da8f40323359bf350e Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Fri, 7 Aug 2026 14:54:01 +0200
Subject: [PATCH 3/6] fix(browser): Convert late-reported performance entries
 against their own time origin

Routes the consumers that convert a monotonic `PerformanceEntry` time long after
the entry was recorded through `performanceTimeToSeconds`, so a clock drift
correction no longer shifts entries that were timed correctly:

- INP and CLS report on pagehide, potentially hours after the interaction or
  layout shift they describe. LCP keeps the cached origin: it starts *at* the
  origin by construction, so moving it would detach it from its pageload parent.
- Replay buffers raw entries and only converts them on flush, which for a
  long-running session can be minutes later.
- Continuous profiling samples are `performance.timeOrigin`-relative like any
  other monotonic time.

Also drops `adjustForOriginChange` from `convertJSSelfProfileToSampledFormat`.
`elapsed_since_start_ns` is a difference between two raw monotonic values, so no
origin belongs in it at all - the profile is anchored to the wall clock by the
enclosing payload's `timestamp`. The term was harmless only because it evaluated
to ~0 whenever the SDK origin matched `performance.timeOrigin`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../browser-utils/src/web-vitals/spans.ts     | 16 ++++++----
 .../test/web-vitals/spans.test.ts             | 29 +++++++++++++++++++
 packages/browser/src/profiling/utils.ts       | 13 ++++-----
 .../src/util/createPerformanceEntries.ts      | 12 +++++---
 .../test/integration/flush.test.ts            |  9 ++++++
 .../unit/util/createPerformanceEntry.test.ts  | 29 +++++++++++++++++++
 6 files changed, 91 insertions(+), 17 deletions(-)

diff --git a/packages/browser-utils/src/web-vitals/spans.ts b/packages/browser-utils/src/web-vitals/spans.ts
index 424180427141..0543fb6c6a80 100644
--- a/packages/browser-utils/src/web-vitals/spans.ts
+++ b/packages/browser-utils/src/web-vitals/spans.ts
@@ -7,6 +7,7 @@ import {
   getClient,
   getRootSpan,
   hasSpanStreamingEnabled,
+  performanceTimeToSeconds,
   SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   spanToJSON,
@@ -297,12 +298,13 @@ export function _sendClsSpan(
 ): void {
   DEBUG_BUILD && debug.log(`Sending CLS span (${clsValue})`);
 
-  const performanceTimeOrigin = browserPerformanceTimeOrigin();
   // A CLS of 0 has no shift to place the span at. It is reported when the navigation it was
   // measured on is already over - the next soft navigation, or pagehide - so the current time would
   // land it outside that navigation, on the route that follows it.
   const offset = entry?.startTime ?? navigationStartTime ?? 0;
-  const startTime = performanceTimeOrigin ? msToSec(performanceTimeOrigin + offset) : timestampInSeconds();
+  // Layout shifts can happen at any point in the page's life, but are only reported on pagehide, so the entry is
+  // converted against the time origin that was in effect when the shift happened.
+  const startTime = performanceTimeToSeconds(offset) ?? timestampInSeconds();
   const firstSourceNode = entry?.sources[0]?.node;
   const selector = entry ? htmlTreeAsString(firstSourceNode) : undefined;
   const componentName = firstSourceNode ? getComponentName(firstSourceNode) : null;
@@ -345,7 +347,9 @@ export function _sendClsSpan(
  */
 export function trackInpAsSpan(client: Client, perNavigation = false): void {
   const performance = getBrowserPerformanceAPI();
-  if (!performance || !browserPerformanceTimeOrigin()) {
+  // `performanceTimeToSeconds` is what the entries are converted with, so it also decides whether they can be converted
+  // at all — `browserPerformanceTimeOrigin` has a `Date.now()` fallback that it does not share.
+  if (!performance || performanceTimeToSeconds(0) === undefined) {
     return;
   }
 
@@ -409,9 +413,9 @@ export function _sendInpSpan(
   // A web vital span carries the metric, not a real interaction timing, so an INP without an entry
   // is still worth reporting. It just has no element or interaction type to describe, and is placed
   // at the start of the navigation it belongs to rather than at the interaction.
-  const startTime = msToSec(
-    (browserPerformanceTimeOrigin() as number) + (entry?.startTime ?? metric?.navigationStartTime ?? 0),
-  );
+  // INP reports on pagehide, potentially long after the interaction itself, so the entry is converted against the time
+  // origin that was in effect when it happened rather than the one in effect now.
+  const startTime = performanceTimeToSeconds(entry?.startTime ?? metric?.navigationStartTime ?? 0) as number;
   const duration = msToSec(inpValue);
   // An INP without an entry has no interaction type to report. It still has to land inside the
   // `ui.interaction.*` family, because falling outside it would hide exactly the fast navigations
diff --git a/packages/browser-utils/test/web-vitals/spans.test.ts b/packages/browser-utils/test/web-vitals/spans.test.ts
index f9182b52d153..915252bdc0cf 100644
--- a/packages/browser-utils/test/web-vitals/spans.test.ts
+++ b/packages/browser-utils/test/web-vitals/spans.test.ts
@@ -22,6 +22,7 @@ vi.mock('@sentry/core', async () => {
   return {
     ...actual,
     browserPerformanceTimeOrigin: vi.fn(),
+    performanceTimeToSeconds: vi.fn(),
     timestampInSeconds: vi.fn(),
     getCurrentScope: vi.fn(),
     getClient: vi.fn(),
@@ -497,6 +498,7 @@ describe('_sendClsSpan', () => {
   beforeEach(() => {
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.timestampInSeconds).mockReturnValue(1.5);
     vi.mocked(htmlTreeAsString).mockImplementation((node: any) => `<${node?.tagName || 'div'}>`);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue(mockSpan as any);
@@ -590,6 +592,7 @@ describe('_sendClsSpan', () => {
 
   it('falls back to the current time when there is no performance time origin', () => {
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(undefined);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockReturnValue(undefined);
 
     _sendClsSpan(0, undefined);
 
@@ -612,6 +615,7 @@ describe('_sendInpSpan', () => {
   beforeEach(() => {
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(htmlTreeAsString).mockReturnValue('<button>');
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue(mockSpan as any);
     vi.mocked(SentryCore.getActiveSpan).mockReturnValue(undefined);
@@ -667,6 +671,29 @@ describe('_sendInpSpan', () => {
     expect(mockSpan.end).toHaveBeenCalledWith(1.62);
   });
 
+  it('times the span against the origin the interaction happened under, not the one in effect at report time', () => {
+    vi.spyOn(inpModule, 'getCachedInteractionContext').mockReturnValue(undefined);
+
+    // INP reports on pagehide. If the device slept in between, the SDK has since re-derived its time origin, but the
+    // interaction itself still belongs to the timeline it happened on.
+    const sleepDurationMs = 3_600_000;
+    vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000 + sleepDurationMs);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time =>
+      time < 500 ? (1000 + sleepDurationMs + time) / 1000 : (1000 + time) / 1000,
+    );
+
+    _sendInpSpan(120, {
+      name: 'pointerdown',
+      startTime: 500,
+      duration: 120,
+      interactionId: 1,
+      target: { tagName: 'button' },
+    } as any);
+
+    expect(SentryCoreBrowser.startInactiveSpan).toHaveBeenCalledWith(expect.objectContaining({ startTime: 1.5 }));
+    expect(mockSpan.end).toHaveBeenCalledWith(1.62);
+  });
+
   it('sends a streamed INP span for a keypress interaction', () => {
     vi.spyOn(inpModule, 'getCachedInteractionContext').mockReturnValue(undefined);
 
@@ -792,6 +819,7 @@ describe('trackInpAsSpan', () => {
 
   beforeEach(() => {
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.getActiveSpan).mockReturnValue(undefined);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue({ end: vi.fn() } as any);
@@ -890,6 +918,7 @@ describe('soft navigation web vitals', () => {
       supportedEntryTypes: ['largest-contentful-paint', 'layout-shift', 'soft-navigation'],
     });
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue({ end: vi.fn() } as any);
     vi.mocked(SentryCore.spanToJSON).mockImplementation(
diff --git a/packages/browser/src/profiling/utils.ts b/packages/browser/src/profiling/utils.ts
index 2669e121ac97..2e8b3911bc94 100644
--- a/packages/browser/src/profiling/utils.ts
+++ b/packages/browser/src/profiling/utils.ts
@@ -1,11 +1,11 @@
 /* eslint-disable max-lines */
 import type { Client, ContinuousThreadCpuProfile, DebugImage, ProfileChunk, Span } from '@sentry/core';
 import {
-  browserPerformanceTimeOrigin,
   debug,
   getClient,
   getDebugImagesForResources,
   GLOBAL_OBJ,
+  performanceTimeToSeconds,
   uuid4,
 } from '@sentry/core';
 import type { BrowserOptions } from '../client';
@@ -147,10 +147,8 @@ function convertToContinuousProfile(input: {
     stacks[i] = list;
   }
 
-  // Align timestamps to SDK time origin to match span/event timelines
-  const perfOrigin = browserPerformanceTimeOrigin();
-  const origin = typeof performance.timeOrigin === 'number' ? performance.timeOrigin : perfOrigin || 0;
-  const adjustForOriginChange = origin - (perfOrigin || origin);
+  // Only used if the SDK cannot convert monotonic times at all, i.e. when the Performance API is unavailable.
+  const origin = typeof performance.timeOrigin === 'number' ? performance.timeOrigin : 0;
 
   const samples: ContinuousThreadCpuProfile['samples'] = [];
   for (let i = 0; i < input.samples.length; i++) {
@@ -158,8 +156,9 @@ function convertToContinuousProfile(input: {
     if (!sample) {
       continue;
     }
-    // Convert ms to seconds epoch-based timestamp
-    const timestampSeconds = (origin + (sample.timestamp - adjustForOriginChange)) / 1000;
+    // Sample timestamps are `performance.timeOrigin`-relative, so they are converted the same way as any other
+    // monotonic time to keep the profile on the span and event timeline.
+    const timestampSeconds = performanceTimeToSeconds(sample.timestamp) ?? (origin + sample.timestamp) / 1000;
     samples[i] = {
       stack_id: sample.stackId ?? 0,
       thread_id: PROFILER_THREAD_ID_STRING,
diff --git a/packages/replay-internal/src/util/createPerformanceEntries.ts b/packages/replay-internal/src/util/createPerformanceEntries.ts
index 5d3435b7efbc..c2980e790ce5 100644
--- a/packages/replay-internal/src/util/createPerformanceEntries.ts
+++ b/packages/replay-internal/src/util/createPerformanceEntries.ts
@@ -1,4 +1,4 @@
-import { browserPerformanceTimeOrigin } from '@sentry/core';
+import { performanceTimeToSeconds } from '@sentry/core';
 import { record } from '@sentry/rrweb';
 import { WINDOW } from '../constants';
 import type {
@@ -87,9 +87,13 @@ function createPerformanceEntry(entry: AllPerformanceEntry): ReplayPerformanceEn
 }
 
 function getAbsoluteTime(time: number): number {
-  // browserPerformanceTimeOrigin can be undefined if `performance` or
-  // `performance.now` doesn't exist, but this is already checked by this integration
-  return ((browserPerformanceTimeOrigin() || WINDOW.performance.timeOrigin) + time) / 1000;
+  // Entries are buffered raw and only converted here, on flush, which for a long-running session can be minutes after
+  // they were observed and across a clock drift correction. `performanceTimeToSeconds` resolves each entry against the
+  // time origin that was in effect when it was recorded, so a later correction does not retroactively shift entries
+  // that were timed correctly.
+  // It returns undefined if `performance` or `performance.now` doesn't exist, but this is already checked by this
+  // integration.
+  return performanceTimeToSeconds(time) ?? (WINDOW.performance.timeOrigin + time) / 1000;
 }
 
 function createPaintEntry(entry: PerformancePaintTiming): ReplayPerformanceEntry<PaintData> {
diff --git a/packages/replay-internal/test/integration/flush.test.ts b/packages/replay-internal/test/integration/flush.test.ts
index c7132595a424..ccc8ae8c607f 100644
--- a/packages/replay-internal/test/integration/flush.test.ts
+++ b/packages/replay-internal/test/integration/flush.test.ts
@@ -28,6 +28,7 @@ type MockRunFlush = MockedFunction<ReplayContainer['_runFlush']>;
 
 const prevLocation = WINDOW.location;
 const prevBrowserPerformanceTimeOrigin = SentryUtils.browserPerformanceTimeOrigin;
+const prevPerformanceTimeToSeconds = SentryUtils.performanceTimeToSeconds;
 
 describe('Integration | flush', () => {
   let domHandler: DomHandler;
@@ -92,6 +93,10 @@ describe('Integration | flush', () => {
       value: () => BASE_TIMESTAMP,
       writable: true,
     });
+    Object.defineProperty(SentryUtils, 'performanceTimeToSeconds', {
+      value: (time: number) => (BASE_TIMESTAMP + time) / 1000,
+      writable: true,
+    });
   });
 
   afterEach(async () => {
@@ -106,6 +111,10 @@ describe('Integration | flush', () => {
       value: () => prevBrowserPerformanceTimeOrigin,
       writable: true,
     });
+    Object.defineProperty(SentryUtils, 'performanceTimeToSeconds', {
+      value: prevPerformanceTimeToSeconds,
+      writable: true,
+    });
   });
 
   afterAll(() => {
diff --git a/packages/replay-internal/test/unit/util/createPerformanceEntry.test.ts b/packages/replay-internal/test/unit/util/createPerformanceEntry.test.ts
index c87d18bff325..ea82d581c776 100644
--- a/packages/replay-internal/test/unit/util/createPerformanceEntry.test.ts
+++ b/packages/replay-internal/test/unit/util/createPerformanceEntry.test.ts
@@ -1,4 +1,5 @@
 import '../../utils/mock-internal-setTimeout';
+import { performanceTimeToSeconds } from '@sentry/core';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { WINDOW } from '../../../src/constants';
 import {
@@ -9,9 +10,12 @@ import {
 } from '../../../src/util/createPerformanceEntries';
 import { PerformanceEntryNavigation } from '../../fixtures/performanceEntry/navigation';
 
+const TIME_ORIGIN = new Date('2023-01-01').getTime();
+
 vi.mock('@sentry/core', async () => ({
   ...(await vi.importActual('@sentry/core')),
   browserPerformanceTimeOrigin: () => new Date('2023-01-01').getTime(),
+  performanceTimeToSeconds: vi.fn((time: number) => (new Date('2023-01-01').getTime() + time) / 1000),
 }));
 
 describe('Unit | util | createPerformanceEntries', () => {
@@ -21,6 +25,8 @@ describe('Unit | util | createPerformanceEntries', () => {
   });
 
   beforeEach(function () {
+    vi.mocked(performanceTimeToSeconds).mockImplementation(time => (TIME_ORIGIN + time) / 1000);
+
     if (!WINDOW.performance.getEntriesByType) {
       WINDOW.performance.getEntriesByType = vi.fn((type: string) => {
         if (type === 'navigation') {
@@ -67,6 +73,29 @@ describe('Unit | util | createPerformanceEntries', () => {
     expect(createPerformanceEntries([data])).toEqual([]);
   });
 
+  it('converts a buffered entry against the origin it was observed with', () => {
+    // Entries are buffered raw and converted here on flush, which for a long session can happen after a clock drift
+    // correction. Only times past the drift point resolve to the corrected origin.
+    const driftPointMs = 200_000;
+    const sleepDurationMs = 3_600_000;
+    vi.mocked(performanceTimeToSeconds).mockImplementation(time =>
+      time < driftPointMs ? (TIME_ORIGIN + time) / 1000 : (TIME_ORIGIN + sleepDurationMs + time) / 1000,
+    );
+
+    const entries = createPerformanceEntries([
+      { name: 'first-paint', entryType: 'paint', startTime: 1000, duration: 0 },
+      { name: 'first-contentful-paint', entryType: 'paint', startTime: driftPointMs + 1000, duration: 0 },
+    ] as PerformanceEntry[]);
+
+    expect(entries).toEqual([
+      expect.objectContaining({ name: 'first-paint', start: (TIME_ORIGIN + 1000) / 1000 }),
+      expect.objectContaining({
+        name: 'first-contentful-paint',
+        start: (TIME_ORIGIN + sleepDurationMs + driftPointMs + 1000) / 1000,
+      }),
+    ]);
+  });
+
   describe('getLargestContentfulPaint', () => {
     it('works with an LCP metric', async () => {
       const metric = {

From 666afe60c17d71ad2a0a733cc8308d8034dc9a37 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 28 Sep 2026 16:40:33 +0200
Subject: [PATCH 4/6] fix(browser): Resolve every performance entry against its
 own time origin

`browserPerformanceTimeOrigin` was cached at init, so after a drift correction
resource, long task, long animation frame, click and user timing spans landed a
whole sleep before the navigation they belong to, and most were dropped by the
"started before the navigation" checks. It now takes the monotonic time being
converted and returns the origin in effect then, defaulting to the page load.

Also:
- Soft navigation LCP resolves against the origin at the navigation start.
- A correction now applies from the previous check on, so the interaction that
  wakes the SDK up after a sleep lands on the corrected timeline.
- The page load origin survives the segment cap.
- Without `performance.timeOrigin`, monotonic times convert against
  `Date.now() - performance.now()` again instead of producing `NaN`.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../browser-utils/src/performance/entries.ts  |  10 +-
 .../src/performance/interactions.ts           |   4 +-
 .../src/performance/resourceTiming.ts         |  32 +++---
 .../src/performance/userTiming.ts             |   6 +-
 .../browser-utils/src/web-vitals/spans.ts     |   9 +-
 .../performance/addPerformanceEntries.test.ts |  79 +++++++++++++
 .../test/web-vitals/spans.test.ts             |  16 +++
 packages/core/src/utils/time.ts               | 108 +++++++-----------
 packages/core/test/lib/utils/time.test.ts     |  68 ++++++++++-
 9 files changed, 230 insertions(+), 102 deletions(-)
 create mode 100644 packages/browser-utils/test/performance/addPerformanceEntries.test.ts

diff --git a/packages/browser-utils/src/performance/entries.ts b/packages/browser-utils/src/performance/entries.ts
index f28e60f1cb3e..bf36aa607e62 100644
--- a/packages/browser-utils/src/performance/entries.ts
+++ b/packages/browser-utils/src/performance/entries.ts
@@ -5,6 +5,7 @@ import {
   browserPerformanceTimeOrigin,
   getActiveSpan,
   parseUrl,
+  performanceTimeToSeconds,
   RESOURCE_SPAN_NAME_FALLBACK,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   setMeasurement,
@@ -108,7 +109,7 @@ export function startTrackingLongTasks(): void {
     const { attributes: parentAttributes, start_timestamp: parentStartTimestamp } = spanToJSON(parent);
 
     for (const entry of entries) {
-      const startTime = msToSec((browserPerformanceTimeOrigin() as number) + entry.startTime);
+      const startTime = performanceTimeToSeconds(entry.startTime) as number;
       const duration = msToSec(entry.duration);
 
       if (parentAttributes[SENTRY_OP] === 'navigation' && parentStartTimestamp && startTime < parentStartTimestamp) {
@@ -147,7 +148,7 @@ export function startTrackingLongAnimationFrames(): void {
         continue;
       }
 
-      const startTime = msToSec((browserPerformanceTimeOrigin() as number) + entry.startTime);
+      const startTime = performanceTimeToSeconds(entry.startTime) as number;
 
       const {
         start_timestamp: parentStartTimestamp,
@@ -217,13 +218,14 @@ export function addPerformanceEntries(span: Span, options: AddPerformanceEntries
 
   const { spanStreamingEnabled, ignoreResourceSpans } = options;
 
-  const timeOrigin = msToSec(origin);
-
   const performanceEntries = performance.getEntries();
 
   const { attributes, start_timestamp: transactionStartTime } = spanToJSON(span);
 
   performanceEntries.slice(_performanceCursor).forEach(entry => {
+    // Navigations can happen long after page load, and after a clock drift correction. All timings of an entry share
+    // the origin in effect when it started, so the entry keeps its duration.
+    const timeOrigin = msToSec(browserPerformanceTimeOrigin(entry.startTime) as number);
     const startTime = msToSec(entry.startTime);
     const duration = msToSec(
       // Inexplicably, Chrome sometimes emits a negative duration. We need to work around this.
diff --git a/packages/browser-utils/src/performance/interactions.ts b/packages/browser-utils/src/performance/interactions.ts
index 7a3cc89a981d..433cd32318e2 100644
--- a/packages/browser-utils/src/performance/interactions.ts
+++ b/packages/browser-utils/src/performance/interactions.ts
@@ -16,13 +16,13 @@ import {
 import { UI_ACTION_CLICK, UI_INTERACTION_CLICK } from '@sentry/conventions/op';
 import type { Client, IntegrationFn, Span, StartSpanOptions, TransactionSource } from '@sentry/core';
 import {
-  browserPerformanceTimeOrigin,
   debug,
   defineIntegration,
   filterCollectedUrl,
   getActiveSpan,
   getRootSpan,
   hasSpanStreamingEnabled,
+  performanceTimeToSeconds,
   spanToJSON,
   UI_ACTION_CLICK_SPAN_NAME_FALLBACK,
   UI_INTERACTION_CLICK_SPAN_NAME_FALLBACK,
@@ -242,7 +242,7 @@ function trackInteractionsAsSpans(client: Client): void {
     }
     for (const entry of entries) {
       if (entry.name === 'click') {
-        const startTime = msToSec((browserPerformanceTimeOrigin() as number) + entry.startTime);
+        const startTime = performanceTimeToSeconds(entry.startTime) as number;
         const duration = msToSec(entry.duration);
 
         const selector = htmlTreeAsString(entry.target);
diff --git a/packages/browser-utils/src/performance/resourceTiming.ts b/packages/browser-utils/src/performance/resourceTiming.ts
index 5a711d307cf3..eb0a782b2986 100644
--- a/packages/browser-utils/src/performance/resourceTiming.ts
+++ b/packages/browser-utils/src/performance/resourceTiming.ts
@@ -2,10 +2,10 @@ import type { SpanAttributes } from '@sentry/core';
 import { browserPerformanceTimeOrigin } from '@sentry/core';
 import { extractNetworkProtocol, getBrowserPerformanceAPI } from './utils';
 
-function getAbsoluteTime(time: number | undefined): number | undefined {
+function getAbsoluteTime(time: number | undefined, timeOrigin: number): number | undefined {
   // falsy values should be preserved so that we can later on drop undefined values and
   // preserve 0 vals for cross-origin resources without proper `Timing-Allow-Origin` header.
-  return time ? ((browserPerformanceTimeOrigin() || performance.timeOrigin) + time) / 1000 : time;
+  return time ? (timeOrigin + time) / 1000 : time;
 }
 
 /**
@@ -28,31 +28,33 @@ export function resourceTimingToSpanAttributes(resourceTiming: PerformanceResour
     timingSpanData['network.protocol.name'] = name;
   }
 
-  if (!(browserPerformanceTimeOrigin() || getBrowserPerformanceAPI()?.timeOrigin)) {
+  // All timings share the origin in effect when the request started, so the phases between them stay intact.
+  const timeOrigin = browserPerformanceTimeOrigin(resourceTiming.startTime) || getBrowserPerformanceAPI()?.timeOrigin;
+  if (!timeOrigin) {
     return timingSpanData;
   }
 
   return dropUndefinedKeysFromObject({
     ...timingSpanData,
 
-    'http.request.redirect_start': getAbsoluteTime(resourceTiming.redirectStart),
-    'http.request.redirect_end': getAbsoluteTime(resourceTiming.redirectEnd),
+    'http.request.redirect_start': getAbsoluteTime(resourceTiming.redirectStart, timeOrigin),
+    'http.request.redirect_end': getAbsoluteTime(resourceTiming.redirectEnd, timeOrigin),
 
-    'http.request.worker_start': getAbsoluteTime(resourceTiming.workerStart),
+    'http.request.worker_start': getAbsoluteTime(resourceTiming.workerStart, timeOrigin),
 
-    'http.request.fetch_start': getAbsoluteTime(resourceTiming.fetchStart),
+    'http.request.fetch_start': getAbsoluteTime(resourceTiming.fetchStart, timeOrigin),
 
-    'http.request.domain_lookup_start': getAbsoluteTime(resourceTiming.domainLookupStart),
-    'http.request.domain_lookup_end': getAbsoluteTime(resourceTiming.domainLookupEnd),
+    'http.request.domain_lookup_start': getAbsoluteTime(resourceTiming.domainLookupStart, timeOrigin),
+    'http.request.domain_lookup_end': getAbsoluteTime(resourceTiming.domainLookupEnd, timeOrigin),
 
-    'http.request.connect_start': getAbsoluteTime(resourceTiming.connectStart),
-    'http.request.secure_connection_start': getAbsoluteTime(resourceTiming.secureConnectionStart),
-    'http.request.connection_end': getAbsoluteTime(resourceTiming.connectEnd),
+    'http.request.connect_start': getAbsoluteTime(resourceTiming.connectStart, timeOrigin),
+    'http.request.secure_connection_start': getAbsoluteTime(resourceTiming.secureConnectionStart, timeOrigin),
+    'http.request.connection_end': getAbsoluteTime(resourceTiming.connectEnd, timeOrigin),
 
-    'http.request.request_start': getAbsoluteTime(resourceTiming.requestStart),
+    'http.request.request_start': getAbsoluteTime(resourceTiming.requestStart, timeOrigin),
 
-    'http.request.response_start': getAbsoluteTime(resourceTiming.responseStart),
-    'http.request.response_end': getAbsoluteTime(resourceTiming.responseEnd),
+    'http.request.response_start': getAbsoluteTime(resourceTiming.responseStart, timeOrigin),
+    'http.request.response_end': getAbsoluteTime(resourceTiming.responseEnd, timeOrigin),
 
     // For TTFB we actually want the relative time from timeOrigin to responseStart
     // This way, TTFB always measures the "first page load" experience.
diff --git a/packages/browser-utils/src/performance/userTiming.ts b/packages/browser-utils/src/performance/userTiming.ts
index 02d6fc25694d..18138a2a7fbe 100644
--- a/packages/browser-utils/src/performance/userTiming.ts
+++ b/packages/browser-utils/src/performance/userTiming.ts
@@ -26,11 +26,9 @@ const _userTimingIntegration = ((options: UserTimingOptions = {}) => {
     name: INTEGRATION_NAME,
     setup(client) {
       const performance = getBrowserPerformanceAPI();
-      const timeOrigin = browserPerformanceTimeOrigin();
-      if (!performance?.getEntries || !timeOrigin) {
+      if (!performance?.getEntries || !browserPerformanceTimeOrigin()) {
         return;
       }
-      const timeOriginInSeconds = msToSec(timeOrigin);
       let performanceCursor = 0;
 
       client.on('beforeIdleSpanEnd', idleSpan => {
@@ -49,6 +47,8 @@ const _userTimingIntegration = ((options: UserTimingOptions = {}) => {
             continue;
           }
 
+          // Navigations can happen long after page load, and after a clock drift correction.
+          const timeOriginInSeconds = msToSec(browserPerformanceTimeOrigin(entry.startTime) as number);
           const startTime = msToSec(entry.startTime);
           const absoluteStartTime = timeOriginInSeconds + startTime;
 
diff --git a/packages/browser-utils/src/web-vitals/spans.ts b/packages/browser-utils/src/web-vitals/spans.ts
index 0543fb6c6a80..94fb175bc32a 100644
--- a/packages/browser-utils/src/web-vitals/spans.ts
+++ b/packages/browser-utils/src/web-vitals/spans.ts
@@ -194,10 +194,11 @@ export function _sendLcpSpan(
 
   DEBUG_BUILD && debug.log(`Sending LCP span (${lcpValue})`);
 
-  const performanceTimeOrigin = browserPerformanceTimeOrigin() || 0;
   // A soft navigation's LCP is measured from the triggering interaction, not the document time
   // origin. Starting the span there too keeps it inside the navigation span it is parented to and
-  // keeps its duration equal to the value it reports.
+  // keeps its duration equal to the value it reports. The span's end shares that origin for the
+  // same reason, even if the clock drift was corrected in between.
+  const performanceTimeOrigin = browserPerformanceTimeOrigin(navigationStartTime || 0) || 0;
   const startTime = msToSec(performanceTimeOrigin + (navigationStartTime || 0));
   // Without an entry there is no render time to end at, so the span lasts the value it reports,
   // like an entry-less INP does. Ending at the time origin instead would invert the span.
@@ -347,9 +348,7 @@ export function _sendClsSpan(
  */
 export function trackInpAsSpan(client: Client, perNavigation = false): void {
   const performance = getBrowserPerformanceAPI();
-  // `performanceTimeToSeconds` is what the entries are converted with, so it also decides whether they can be converted
-  // at all — `browserPerformanceTimeOrigin` has a `Date.now()` fallback that it does not share.
-  if (!performance || performanceTimeToSeconds(0) === undefined) {
+  if (!performance || !browserPerformanceTimeOrigin()) {
     return;
   }
 
diff --git a/packages/browser-utils/test/performance/addPerformanceEntries.test.ts b/packages/browser-utils/test/performance/addPerformanceEntries.test.ts
new file mode 100644
index 000000000000..4a8f412be4f8
--- /dev/null
+++ b/packages/browser-utils/test/performance/addPerformanceEntries.test.ts
@@ -0,0 +1,79 @@
+import type { Span } from '@sentry/core';
+import * as SentryCore from '@sentry/core';
+import { getClient, getMainCarrier, SentrySpan, setCurrentClient, spanToJSON } from '@sentry/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { addPerformanceEntries } from '../../src/performance/entries';
+import { WINDOW } from '../../src/types';
+import { getDefaultClientOptions, TestClient } from '../utils/TestClient';
+
+vi.mock('@sentry/core', async () => {
+  const actual = await vi.importActual('@sentry/core');
+  return {
+    ...actual,
+    browserPerformanceTimeOrigin: vi.fn(),
+  };
+});
+
+const pageloadOriginMs = 1_000_000;
+const sleepDurationMs = 3_600_000;
+// The monotonic time from which the SDK applies the origin it re-derived after the device slept.
+const correctionFromMs = 10_000;
+
+describe('addPerformanceEntries', () => {
+  beforeEach(() => {
+    getMainCarrier().__SENTRY__ = undefined;
+    const client = new TestClient(getDefaultClientOptions({ tracesSampleRate: 1 }));
+    setCurrentClient(client);
+    client.init();
+
+    vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockImplementation((monotonicTimeInMs = 0) =>
+      monotonicTimeInMs < correctionFromMs ? pageloadOriginMs : pageloadOriginMs + sleepDurationMs,
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it('keeps the resource spans of a navigation that happens after a clock drift correction', () => {
+    const resourceStartTime = 12_000;
+    vi.stubGlobal('addEventListener', vi.fn());
+    vi.stubGlobal('location', { origin: 'https://example.com' });
+    vi.spyOn(WINDOW.performance, 'getEntries').mockReturnValue([
+      {
+        entryType: 'resource',
+        name: 'https://example.com/app.js',
+        initiatorType: 'script',
+        startTime: resourceStartTime,
+        duration: 100,
+        responseEnd: resourceStartTime + 100,
+        toJSON: () => ({}),
+      } as PerformanceResourceTiming,
+    ]);
+
+    const navigationStartTimestamp = (pageloadOriginMs + sleepDurationMs + resourceStartTime - 50) / 1000;
+    const span = new SentrySpan({
+      op: 'navigation',
+      name: '/next',
+      sampled: true,
+      startTimestamp: navigationStartTimestamp,
+    });
+
+    const endedSpans: Span[] = [];
+    getClient()?.on('spanEnd', endedSpan => void endedSpans.push(endedSpan));
+
+    addPerformanceEntries(span, { ignoreResourceSpans: [] });
+
+    expect(endedSpans.map(spanToJSON)).toEqual([
+      expect.objectContaining({
+        start_timestamp: (pageloadOriginMs + sleepDurationMs + resourceStartTime) / 1000,
+        end_timestamp: (pageloadOriginMs + sleepDurationMs + resourceStartTime + 100) / 1000,
+        attributes: expect.objectContaining({
+          'sentry.op': 'resource.script',
+          'http.request.response_end': (pageloadOriginMs + sleepDurationMs + resourceStartTime + 100) / 1000,
+        }),
+      }),
+    ]);
+  });
+});
diff --git a/packages/browser-utils/test/web-vitals/spans.test.ts b/packages/browser-utils/test/web-vitals/spans.test.ts
index 915252bdc0cf..c117b4d1a5f1 100644
--- a/packages/browser-utils/test/web-vitals/spans.test.ts
+++ b/packages/browser-utils/test/web-vitals/spans.test.ts
@@ -476,6 +476,22 @@ describe('_sendLcpSpan', () => {
     expect(mockSpan.end).toHaveBeenCalledWith(3.25);
   });
 
+  it('times a soft navigation LCP against the origin in effect when the navigation started', () => {
+    // The soft navigation happens after the SDK corrected its time origin for a clock drift.
+    const sleepDurationMs = 3_600_000;
+    vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockImplementation((monotonicTimeInMs = 0) =>
+      monotonicTimeInMs < 1500 ? 1000 : 1000 + sleepDurationMs,
+    );
+    const entry = { element: { tagName: 'img' } as Element, startTime: 2250 } as LargestContentfulPaint;
+
+    _sendLcpSpan(250, entry, undefined, 2, 'soft-navigation', 2000);
+
+    expect(SentryCoreBrowser.startInactiveSpan).toHaveBeenCalledWith(
+      expect.objectContaining({ startTime: (1000 + sleepDurationMs + 2000) / 1000 }),
+    );
+    expect(mockSpan.end).toHaveBeenCalledWith((1000 + sleepDurationMs + 2250) / 1000);
+  });
+
   it('drops implausible LCP values', () => {
     _sendLcpSpan(0, undefined);
     _sendLcpSpan(MAX_PLAUSIBLE_LCP_DURATION + 1, undefined);
diff --git a/packages/core/src/utils/time.ts b/packages/core/src/utils/time.ts
index 076e6d408422..26fb984c3c9f 100644
--- a/packages/core/src/utils/time.ts
+++ b/packages/core/src/utils/time.ts
@@ -10,10 +10,10 @@ const ONE_SECOND_IN_MS = 1000;
 const CLOCK_DRIFT_THRESHOLD_MS = 300_000; // 5 minutes in milliseconds
 
 /**
- * Upper bound on the number of drift corrections {@link performanceTimeToSeconds} remembers. A page has to survive that
- * many separate clock jumps to reach it, so the cap only keeps a pathological clock from growing the list without
- * bound. Once reached, the oldest segments are merged away, which at worst makes the very earliest monotonic
- * timestamps convert against a later origin — the same result as not tracking segments at all.
+ * Upper bound on the number of drift corrections {@link browserPerformanceTimeOrigin} remembers. A page has to survive
+ * that many separate clock jumps to reach it, so the cap only keeps a pathological clock from growing the list without
+ * bound. Once reached, the oldest corrections are merged away. The origin at page load is always kept, because the
+ * pageload span and its children are anchored to it.
  */
 const MAX_TIME_ORIGIN_SEGMENTS = 30;
 
@@ -71,6 +71,10 @@ function createUnixTimestampInSecondsFunc(): () => number {
   // Some browser and environments don't have a performance or timeOrigin, so we fallback to
   // using Date.now() to compute the starting time.
   if (!performance?.now || !performance.timeOrigin) {
+    if (performance?.now) {
+      // Monotonic times can still be converted, just without drift correction.
+      _timeOriginSegments = [{ from: 0, origin: safeDateNow() - withRandomSafeContext(() => performance.now()) }];
+    }
     return dateTimestampInSeconds;
   }
 
@@ -79,6 +83,7 @@ function createUnixTimestampInSecondsFunc(): () => number {
   let timeOrigin = performance.timeOrigin;
   _timeOriginSegments = [{ from: 0, origin: timeOrigin }];
   let isFirstCall = true;
+  let lastCheckedPerformanceNow = 0;
 
   return () => {
     return withRandomSafeContext(() => {
@@ -89,29 +94,33 @@ function createUnixTimestampInSecondsFunc(): () => number {
       // performance.now() stops advancing while the device is asleep, so it under-counts elapsed wall time; conversely
       // the wall clock itself can be stepped by Network Time Protocol (NTP) or the user. Either way the two drift apart
       // by arbitrary amounts. Re-deriving the origin restores absolute accuracy while still taking elapsed time from
-      // the monotonic clock, so durations keep sub-millisecond precision and cannot run backwards.
+      // the monotonic clock, so durations keep sub-millisecond precision.
       // Timestamps taken before a correction are measured against a different origin than those taken after it, so a
-      // span that starts before one and ends after it absorbs the drift into its duration. Spans that lie entirely on
-      // one side of a correction are unaffected.
+      // span that starts before one and ends after it absorbs the drift into its duration. If the wall clock was stepped
+      // backwards, that duration can even be negative. Spans that lie entirely on one side of a correction are
+      // unaffected.
       // See: https://github.com/getsentry/sentry-javascript/issues/2590
       // See: https://github.com/mdn/content/issues/4713
       // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6
       if (Math.abs(timeOrigin + performanceNow - dateNow) > CLOCK_DRIFT_THRESHOLD_MS) {
         timeOrigin = dateNow - performanceNow;
         // The very first check runs before any timestamp has been handed out, so a `performance.timeOrigin` that was
-        // already unreliable at startup never applied to anything and is replaced outright. Later corrections only
-        // apply from the point they are detected at — an upper bound on where the drift actually happened, and as
-        // close as it can be pinned down without a second clock. Timestamps taken before that keep their old origin.
+        // already unreliable at startup never applied to anything and is replaced outright.
+        // Later corrections apply from the previous check on, the last point the clocks were known to agree. Drift is
+        // usually only noticed when an interaction wakes the SDK up again, and the entry for that interaction starts
+        // slightly before the check that detects it, so it has to be on the corrected side. The cost is that entries
+        // recorded between that previous check and the device going to sleep are shifted by the drift.
         if (isFirstCall) {
           _timeOriginSegments = [{ from: 0, origin: timeOrigin }];
         } else {
-          _timeOriginSegments.push({ from: performanceNow, origin: timeOrigin });
+          _timeOriginSegments.push({ from: lastCheckedPerformanceNow, origin: timeOrigin });
           if (_timeOriginSegments.length > MAX_TIME_ORIGIN_SEGMENTS) {
-            _timeOriginSegments.shift();
+            _timeOriginSegments.splice(1, 1);
           }
         }
       }
       isFirstCall = false;
+      lastCheckedPerformanceNow = performanceNow;
 
       return (timeOrigin + performanceNow) / ONE_SECOND_IN_MS;
     });
@@ -125,28 +134,11 @@ let _cachedTimestampInSeconds: (() => number) | undefined;
  * `timestamp`, or any other `performance.now()`-relative value in milliseconds) to a wall clock timestamp in seconds
  * since the UNIX epoch, on the same timeline as {@link timestampInSeconds}.
  *
- * Prefer this over combining a monotonic time with {@link browserPerformanceTimeOrigin} by hand: because the SDK
- * re-derives its time origin when the monotonic and wall clocks drift apart, a single origin is only valid for part of
- * the page's lifetime. This picks the origin that was in effect when the passed time was measured, so entries reported
- * long after the fact (INP on pagehide, replay entries buffered until flush) do not get retroactively shifted by a
- * drift that happened after they were recorded.
- *
  * Returns `undefined` if the Performance API is unavailable, in which case monotonic times cannot be converted at all.
  */
 export function performanceTimeToSeconds(monotonicTimeInMs: number): number | undefined {
-  // Segments are only populated once `timestampInSeconds` has resolved which clock source to use.
-  timestampInSeconds();
-
-  let segment: TimeOriginSegment | undefined;
-  for (const candidate of _timeOriginSegments) {
-    // Times preceding the oldest retained segment fall back to it, which is the best guess available for them.
-    if (segment && candidate.from > monotonicTimeInMs) {
-      break;
-    }
-    segment = candidate;
-  }
-
-  return segment && (segment.origin + monotonicTimeInMs) / ONE_SECOND_IN_MS;
+  const origin = browserPerformanceTimeOrigin(monotonicTimeInMs);
+  return origin === undefined ? undefined : (origin + monotonicTimeInMs) / ONE_SECOND_IN_MS;
 }
 
 /**
@@ -167,49 +159,27 @@ export function timestampInSeconds(): number {
 }
 
 /**
- * Cached result of getBrowserTimeOrigin.
- */
-let cachedTimeOrigin: number | null | undefined = null;
-
-/**
- * Gets the time origin and the mode used to determine it.
+ * Returns the time origin (milliseconds since the UNIX epoch that `performance.now() === 0` corresponds to) that was in
+ * effect at the given monotonic time, which defaults to the page load.
  *
- * Unfortunately browsers may report inaccurate time origin data through performance.timeOrigin,
- * which results in poor results in performance data. We only treat time origin data as reliable
- * if it is within a reasonable threshold of the current time.
+ * Because the SDK re-derives its time origin when the monotonic and wall clocks drift apart, a single origin is only
+ * valid for part of the page's lifetime. Pass the monotonic time that is being converted, so that entries reported long
+ * after the fact (INP on pagehide, replay entries buffered until flush) are not shifted by a drift that happened after
+ * they were recorded. Use the same time for every timing of one entry, so its duration stays intact.
  *
- * TODO: move to `@sentry/browser-utils` package.
+ * Returns `undefined` if the Performance API is unavailable.
  */
-function getBrowserTimeOrigin(): number | undefined {
-  const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;
-  if (!performance?.now) {
-    return undefined;
-  }
-
-  const performanceNow = withRandomSafeContext(() => performance.now());
-  const dateNow = safeDateNow();
+export function browserPerformanceTimeOrigin(monotonicTimeInMs = 0): number | undefined {
+  // Segments are only populated once `timestampInSeconds` has resolved which clock source to use.
+  timestampInSeconds();
 
-  const timeOrigin = performance.timeOrigin;
-  if (typeof timeOrigin === 'number') {
-    const timeOriginDelta = Math.abs(timeOrigin + performanceNow - dateNow);
-    if (timeOriginDelta < CLOCK_DRIFT_THRESHOLD_MS) {
-      return timeOrigin;
+  let segment: TimeOriginSegment | undefined;
+  for (const candidate of _timeOriginSegments) {
+    if (segment && candidate.from > monotonicTimeInMs) {
+      break;
     }
+    segment = candidate;
   }
 
-  // timeOrigin is skewed or unavailable, fallback to subtracting
-  // `performance.now()` from `Date.now()`.
-  return dateNow - performanceNow;
-}
-
-/**
- * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
- * performance API is available.
- */
-export function browserPerformanceTimeOrigin(): number | undefined {
-  if (cachedTimeOrigin === null) {
-    cachedTimeOrigin = getBrowserTimeOrigin();
-  }
-
-  return cachedTimeOrigin;
+  return segment?.origin;
 }
diff --git a/packages/core/test/lib/utils/time.test.ts b/packages/core/test/lib/utils/time.test.ts
index c1999fdf2dd0..81f455b40ff5 100644
--- a/packages/core/test/lib/utils/time.test.ts
+++ b/packages/core/test/lib/utils/time.test.ts
@@ -158,7 +158,7 @@ describe('timestampInSeconds', () => {
     }
   });
 
-  it('produces monotonically increasing timestamps when the wall clock steps backwards', async () => {
+  it('follows a backwards wall clock step and stays monotonic afterwards', async () => {
     const currentTimeMs = 1767778040866;
 
     let timeSincePageloadMs = 1_000;
@@ -266,15 +266,17 @@ describe('performanceTimeToSeconds', () => {
 
     const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
 
+    // The last check at which both clocks still agreed is where the corrected origin starts to apply.
+    const lastAgreedCheckMs = monotonicNowMs;
     timestampInSeconds();
 
     const monotonicAdvanceMs = 10;
     vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
-    const correctionPointMs = (monotonicNowMs += monotonicAdvanceMs);
+    monotonicNowMs += monotonicAdvanceMs;
     timestampInSeconds();
 
-    const beforeCorrection = performanceTimeToSeconds(correctionPointMs - 1) as number;
-    const afterCorrection = performanceTimeToSeconds(correctionPointMs + 1) as number;
+    const beforeCorrection = performanceTimeToSeconds(lastAgreedCheckMs - 1) as number;
+    const afterCorrection = performanceTimeToSeconds(lastAgreedCheckMs + 1) as number;
 
     // The two are 2ms apart on the monotonic clock, but the origins they resolve to are a whole sleep apart: the wall
     // clock advanced `sleepDurationMs` while the monotonic clock only advanced `monotonicAdvanceMs`.
@@ -282,6 +284,54 @@ describe('performanceTimeToSeconds', () => {
     expect(afterCorrection - beforeCorrection).toBeCloseTo((driftMs + 2) / 1000, 6);
   });
 
+  it('converts the interaction that wakes the SDK up after a sleep against the corrected origin', async () => {
+    let monotonicNowMs = timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => monotonicNowMs,
+    });
+
+    const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
+
+    timestampInSeconds();
+
+    // After waking up, the user clicks. The click's entry starts when the input arrives, the SDK only notices the
+    // drift a few milliseconds later, while handling that click.
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    const clickStartTime = (monotonicNowMs += 10);
+    monotonicNowMs += 5;
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs + 5));
+    const detectedAt = timestampInSeconds();
+
+    expect(performanceTimeToSeconds(clickStartTime)).toBeCloseTo(detectedAt - 0.005, 6);
+  });
+
+  it('keeps the page load origin once the number of remembered corrections is exceeded', async () => {
+    let monotonicNowMs = timeSincePageloadMs;
+    let wallNowMs = currentTimeMs;
+    const timeOrigin = currentTimeMs - timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(wallNowMs));
+    vi.stubGlobal('performance', { timeOrigin, now: () => monotonicNowMs });
+
+    const { browserPerformanceTimeOrigin, timestampInSeconds } = await getFreshTimeModule();
+
+    timestampInSeconds();
+    for (let i = 0; i < 40; i++) {
+      monotonicNowMs += 1_000;
+      wallNowMs += 1_000 + sleepDurationMs;
+      vi.setSystemTime(new Date(wallNowMs));
+      timestampInSeconds();
+    }
+
+    expect(browserPerformanceTimeOrigin()).toBe(timeOrigin);
+    expect(browserPerformanceTimeOrigin(monotonicNowMs)).toBe(wallNowMs - monotonicNowMs);
+  });
+
   it('converts times preceding the oldest known origin against that origin', async () => {
     const timeOrigin = currentTimeMs - timeSincePageloadMs;
 
@@ -311,6 +361,16 @@ describe('performanceTimeToSeconds', () => {
     expect(performanceTimeToSeconds(0)).toBe((currentTimeMs - timeSincePageloadMs) / 1000);
   });
 
+  it('converts against `Date.now() - performance.now()` if `performance.timeOrigin` is not available', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', { timeOrigin: undefined, now: () => timeSincePageloadMs });
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(500)).toBe((currentTimeMs - timeSincePageloadMs + 500) / 1000);
+  });
+
   it('returns `undefined` if the performance API is unavailable', async () => {
     vi.stubGlobal('performance', undefined);
 

From 86f158aebef7027b7ad145d5969ccecea6c8f289 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 28 Sep 2026 18:00:57 +0200
Subject: [PATCH 5/6] fix(browser): Check for clock drift when the page is
 hidden and shown

A drift correction applies from the last check at which both clocks agreed, so
entries recorded between that check and the device going to sleep land on the
wrong side of it. Devices usually hide the page before sleeping and show it
again on wake, so checking the clocks on `visibilitychange` pins the correction
to the sleep itself rather than to whenever the SDK next takes a timestamp.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 packages/browser/src/client.ts       |  7 ++++++-
 packages/browser/test/client.test.ts | 27 +++++++++++++++++++++++++--
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/packages/browser/src/client.ts b/packages/browser/src/client.ts
index 0221ca2d30ce..13daf7d0ade1 100644
--- a/packages/browser/src/client.ts
+++ b/packages/browser/src/client.ts
@@ -8,7 +8,7 @@ import type {
   SeverityLevel,
 } from '@sentry/core';
 import type { BrowserClientReplayOptions } from '@sentry/core/browser';
-import { addAutoIpAddressToSession, applySdkMetadata, Client, getSDKSource } from '@sentry/core';
+import { addAutoIpAddressToSession, applySdkMetadata, Client, getSDKSource, timestampInSeconds } from '@sentry/core';
 import { eventFromException, eventFromMessage } from './eventbuilder';
 import { WINDOW } from './helpers';
 import type { BrowserTransportOptions } from './transports/types';
@@ -130,6 +130,11 @@ export class BrowserClient extends Client<BrowserClientOptions> {
     // Client report outcomes don't listen to the `flush` hook, so we flush them separately.
     if (WINDOW.document) {
       WINDOW.document.addEventListener('visibilitychange', () => {
+        // Devices usually hide the page before they go to sleep and show it again when they wake up. Checking the
+        // clocks at both points pins a clock drift correction to the sleep itself, rather than to whenever the SDK
+        // happens to take its next timestamp, so performance entries on either side of it convert correctly.
+        timestampInSeconds();
+
         if (WINDOW.document.visibilityState === 'hidden') {
           if (sendClientReports) {
             this._flushOutcomes();
diff --git a/packages/browser/test/client.test.ts b/packages/browser/test/client.test.ts
index cc7a6cbbafc9..e9752891877e 100644
--- a/packages/browser/test/client.test.ts
+++ b/packages/browser/test/client.test.ts
@@ -2,19 +2,29 @@
  * @vitest-environment jsdom
  */
 
+import * as SentryCore from '@sentry/core';
 import { getCurrentScope, makeSession, setCurrentClient } from '@sentry/core';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { applyDefaultOptions, BrowserClient } from '../src/client';
 import { WINDOW } from '../src/helpers';
 import { getDefaultBrowserClientOptions } from './helper/browser-client-options';
 
-function setDocumentHidden(): void {
+vi.mock('@sentry/core', async importOriginal => {
+  const actual = await importOriginal<typeof SentryCore>();
+  return { ...actual, timestampInSeconds: vi.fn(actual.timestampInSeconds) };
+});
+
+function setDocumentVisibility(visibilityState: DocumentVisibilityState): void {
   if (WINDOW.document) {
-    Object.defineProperty(WINDOW.document, 'visibilityState', { value: 'hidden', configurable: true });
+    Object.defineProperty(WINDOW.document, 'visibilityState', { value: visibilityState, configurable: true });
     WINDOW.document.dispatchEvent(new Event('visibilitychange'));
   }
 }
 
+function setDocumentHidden(): void {
+  setDocumentVisibility('hidden');
+}
+
 describe('BrowserClient', () => {
   let client: BrowserClient;
 
@@ -39,6 +49,19 @@ describe('BrowserClient', () => {
     expect(flushSpy).toHaveBeenCalledTimes(1);
   });
 
+  it('checks the clocks for drift when the page is hidden and shown again', () => {
+    client = new BrowserClient(getDefaultBrowserClientOptions());
+    vi.spyOn(client, 'flush').mockReturnValue(Promise.resolve(true) as any);
+    vi.mocked(SentryCore.timestampInSeconds).mockClear();
+
+    setDocumentHidden();
+    expect(SentryCore.timestampInSeconds).toHaveBeenCalled();
+
+    vi.mocked(SentryCore.timestampInSeconds).mockClear();
+    setDocumentVisibility('visible');
+    expect(SentryCore.timestampInSeconds).toHaveBeenCalled();
+  });
+
   it('does not flush outcomes when sendClientReports is disabled but still flushes the client', async () => {
     client = new BrowserClient(getDefaultBrowserClientOptions({ sendClientReports: false }));
     const flushSpy = vi.spyOn(client, 'flush').mockReturnValue(Promise.resolve(true) as any);

From 7c6a950d1e9cd4690fefcf2b143ce8a0b1dc4250 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 28 Sep 2026 18:41:22 +0200
Subject: [PATCH 6/6] fix(core): Lower the clock drift threshold to 15 seconds

At 5 minutes, any sleep shorter than that left spans, logs and metrics behind
the wall clock (and errors) for the rest of the page's life. 15 seconds is still
far above `Date.now()` jitter and typical NTP adjustments, so it only catches
real drift.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 packages/core/src/utils/time.ts           | 2 +-
 packages/core/test/lib/utils/time.test.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/core/src/utils/time.ts b/packages/core/src/utils/time.ts
index 26fb984c3c9f..10b2d767c001 100644
--- a/packages/core/src/utils/time.ts
+++ b/packages/core/src/utils/time.ts
@@ -7,7 +7,7 @@ const ONE_SECOND_IN_MS = 1000;
  * Maximum tolerated difference between the monotonic clock and the wall clock before we consider
  * the monotonic clock's time origin stale.
  */
-const CLOCK_DRIFT_THRESHOLD_MS = 300_000; // 5 minutes in milliseconds
+const CLOCK_DRIFT_THRESHOLD_MS = 15_000; // 15 seconds in milliseconds
 
 /**
  * Upper bound on the number of drift corrections {@link browserPerformanceTimeOrigin} remembers. A page has to survive
diff --git a/packages/core/test/lib/utils/time.test.ts b/packages/core/test/lib/utils/time.test.ts
index 81f455b40ff5..8ec430c135a4 100644
--- a/packages/core/test/lib/utils/time.test.ts
+++ b/packages/core/test/lib/utils/time.test.ts
@@ -22,7 +22,7 @@ async function getFreshTimestampInSeconds(): Promise<() => number> {
   return (await getFreshTimeModule()).timestampInSeconds;
 }
 
-const RELIABLE_THRESHOLD_MS = 300_000;
+const RELIABLE_THRESHOLD_MS = 15_000;
 
 describe('timestampInSeconds', () => {
   afterEach(() => {