diff --git a/packages/clerk-js/src/core/__tests__/tokenCache.test.ts b/packages/clerk-js/src/core/__tests__/tokenCache.test.ts
index a5d7f892bb8..eec3d16ce04 100644
--- a/packages/clerk-js/src/core/__tests__/tokenCache.test.ts
+++ b/packages/clerk-js/src/core/__tests__/tokenCache.test.ts
@@ -206,9 +206,9 @@ describe('SessionTokenCache', () => {
       } as MessageEvent<SessionTokenEvent>;
 
       broadcastListener(newerEvent);
-      const cachedEntryAfterNewer = SessionTokenCache.get({ tokenId: 'session_123' });
-      expect(cachedEntryAfterNewer).toBeDefined();
-      const newerCreatedAt = cachedEntryAfterNewer?.createdAt;
+      const resultAfterNewer = SessionTokenCache.get({ tokenId: 'session_123' });
+      expect(resultAfterNewer).toBeDefined();
+      const newerCreatedAt = resultAfterNewer?.entry.createdAt;
 
       // mockJwt has iat: 1666648250, so create an older one with iat: 1666648190 (60 seconds earlier)
       const olderJwt =
@@ -226,9 +226,9 @@ describe('SessionTokenCache', () => {
 
       broadcastListener(olderEvent);
 
-      const cachedEntryAfterOlder = SessionTokenCache.get({ tokenId: 'session_123' });
-      expect(cachedEntryAfterOlder).toBeDefined();
-      expect(cachedEntryAfterOlder?.createdAt).toBe(newerCreatedAt);
+      const resultAfterOlder = SessionTokenCache.get({ tokenId: 'session_123' });
+      expect(resultAfterOlder).toBeDefined();
+      expect(resultAfterOlder?.entry.createdAt).toBe(newerCreatedAt);
     });
 
     it('successfully updates cache with valid token', () => {
@@ -245,9 +245,9 @@ describe('SessionTokenCache', () => {
 
       broadcastListener(event);
 
-      const cachedEntry = SessionTokenCache.get({ tokenId: 'session_123' });
-      expect(cachedEntry).toBeDefined();
-      expect(cachedEntry?.tokenId).toBe('session_123');
+      const result = SessionTokenCache.get({ tokenId: 'session_123' });
+      expect(result).toBeDefined();
+      expect(result?.entry.tokenId).toBe('session_123');
     });
 
     it('does not re-broadcast when receiving a broadcast message', async () => {
@@ -271,8 +271,8 @@ describe('SessionTokenCache', () => {
       await Promise.resolve();
 
       // Verify cache was updated
-      const cachedEntry = SessionTokenCache.get({ tokenId: 'session_123' });
-      expect(cachedEntry).toBeDefined();
+      const result = SessionTokenCache.get({ tokenId: 'session_123' });
+      expect(result).toBeDefined();
 
       // Critical: postMessage should NOT be called when handling a broadcast
       expect(mockBroadcastChannel.postMessage).not.toHaveBeenCalled();
@@ -331,9 +331,10 @@ describe('SessionTokenCache', () => {
       // Wait for promise to resolve
       await tokenResolver;
 
-      const cachedEntry = SessionTokenCache.get({ tokenId: 'future_token' });
-      expect(cachedEntry).toBeDefined();
-      expect(cachedEntry?.tokenId).toBe('future_token');
+      const result = SessionTokenCache.get({ tokenId: 'future_token' });
+      expect(result).toBeDefined();
+      expect(result?.entry.tokenId).toBe('future_token');
+      expect(result?.needsRefresh).toBe(false);
     });
 
     it('removes token when it has already expired based on duration', async () => {
@@ -351,11 +352,11 @@ describe('SessionTokenCache', () => {
 
       await tokenResolver;
 
-      const cachedEntry = SessionTokenCache.get({ tokenId: 'expired_token' });
-      expect(cachedEntry).toBeUndefined();
+      const result = SessionTokenCache.get({ tokenId: 'expired_token' });
+      expect(result).toBeUndefined();
     });
 
-    it('removes token when it expires within the leeway threshold', async () => {
+    it('returns token with needsRefresh when remaining TTL is less than leeway (SWR)', async () => {
       const nowSeconds = Math.floor(Date.now() / 1000);
       const iat = nowSeconds;
       const exp = iat + 20;
@@ -366,12 +367,16 @@ describe('SessionTokenCache', () => {
         jwt: { claims: { exp, iat } },
       } as any);
 
-      SessionTokenCache.set({ createdAt: nowSeconds - 13, tokenId: 'soon_expired_token', tokenResolver });
+      // Token has 20s TTL, created 11s ago = 9s remaining (< 10s default leeway)
+      SessionTokenCache.set({ createdAt: nowSeconds - 11, tokenId: 'soon_expired_token', tokenResolver });
 
       await tokenResolver;
 
-      const cachedEntry = SessionTokenCache.get({ tokenId: 'soon_expired_token' });
-      expect(cachedEntry).toBeUndefined();
+      // SWR: Token is still valid (9s > 0), so it should be returned with needsRefresh=true
+      const result = SessionTokenCache.get({ tokenId: 'soon_expired_token' });
+      expect(result).toBeDefined();
+      expect(result?.entry.tokenId).toBe('soon_expired_token');
+      expect(result?.needsRefresh).toBe(true);
     });
 
     it('returns token when expiresAt is undefined (promise not yet resolved)', () => {
@@ -380,9 +385,9 @@ describe('SessionTokenCache', () => {
 
       SessionTokenCache.set({ tokenId: 'pending_token', tokenResolver: pendingTokenResolver });
 
-      const cachedEntry = SessionTokenCache.get({ tokenId: 'pending_token' });
-      expect(cachedEntry).toBeDefined();
-      expect(cachedEntry?.tokenId).toBe('pending_token');
+      const result = SessionTokenCache.get({ tokenId: 'pending_token' });
+      expect(result).toBeDefined();
+      expect(result?.entry.tokenId).toBe('pending_token');
     });
   });
 
@@ -471,7 +476,7 @@ describe('SessionTokenCache', () => {
       SessionTokenCache.set({ ...key, tokenResolver });
       await tokenResolver;
 
-      expect(SessionTokenCache.get(key)).toBeDefined();
+      expect(SessionTokenCache.get(key)?.entry).toBeDefined();
       expect(SessionTokenCache.size()).toBe(1);
 
       SessionTokenCache.clear();
@@ -512,56 +517,142 @@ describe('SessionTokenCache', () => {
 
       SessionTokenCache.set({ ...key, tokenResolver });
 
-      const cachedWhilePending = SessionTokenCache.get(key);
-      expect(cachedWhilePending).toBeDefined();
-      expect(cachedWhilePending?.tokenId).toBe('lifecycle-token');
+      const resultWhilePending = SessionTokenCache.get(key);
+      expect(resultWhilePending).toBeDefined();
+      expect(resultWhilePending?.entry.tokenId).toBe('lifecycle-token');
       expect(isResolved).toBe(false);
 
       vi.advanceTimersByTime(100);
       await tokenResolver;
 
-      const cachedAfterResolved = SessionTokenCache.get(key);
+      const resultAfterResolved = SessionTokenCache.get(key);
       expect(isResolved).toBe(true);
-      expect(cachedAfterResolved).toBeDefined();
-      expect(cachedAfterResolved?.tokenId).toBe('lifecycle-token');
+      expect(resultAfterResolved).toBeDefined();
+      expect(resultAfterResolved?.entry.tokenId).toBe('lifecycle-token');
 
       vi.advanceTimersByTime(60 * 1000);
 
-      const cachedAfterExpiration = SessionTokenCache.get(key);
-      expect(cachedAfterExpiration).toBeUndefined();
+      const resultAfterExpiration = SessionTokenCache.get(key);
+      expect(resultAfterExpiration).toBeUndefined();
     });
   });
 
-  describe('leeway precision', () => {
-    it('includes 5 second sync leeway on top of default 10 second leeway', async () => {
+  describe('SWR leeway behavior', () => {
+    it('returns needsRefresh=false when token has plenty of time remaining', async () => {
       const nowSeconds = Math.floor(Date.now() / 1000);
       const jwt = createJwtWithTtl(nowSeconds, 60);
 
       const token = new Token({
-        id: 'leeway-token',
+        id: 'fresh-token',
         jwt,
         object: 'token',
       });
 
       const tokenResolver = Promise.resolve<TokenResource>(token);
-      const key = { audience: 'leeway-test', tokenId: 'leeway-token' };
+      const key = { audience: 'fresh-test', tokenId: 'fresh-token' };
 
       SessionTokenCache.set({ ...key, tokenResolver });
       await tokenResolver;
 
-      expect(SessionTokenCache.get(key)).toMatchObject({ tokenId: 'leeway-token' });
+      // Token just created, 60s remaining - should return needsRefresh=false
+      const result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('fresh-token');
+      expect(result?.needsRefresh).toBe(false);
+    });
+
+    it('returns needsRefresh=true when token is within default leeway (SWR)', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'expiring-token',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { audience: 'expiring-test', tokenId: 'expiring-token' };
 
+      SessionTokenCache.set({ ...key, tokenResolver });
+      await tokenResolver;
+
+      // At 44s elapsed, 16s remaining - fresh, no refresh needed (> 15s MIN_REMAINING_TTL)
       vi.advanceTimersByTime(44 * 1000);
-      expect(SessionTokenCache.get(key)).toBeDefined();
+      let result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('expiring-token');
+      expect(result?.needsRefresh).toBe(false);
 
-      vi.advanceTimersByTime(1 * 1000);
-      expect(SessionTokenCache.get(key)).toBeDefined();
+      // At 46s elapsed, 14s remaining (< 15s MIN_REMAINING_TTL) - SWR: return token with needsRefresh=true
+      vi.advanceTimersByTime(2 * 1000);
+      result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('expiring-token');
+      expect(result?.needsRefresh).toBe(true);
+
+      // At 60s elapsed, 0s remaining - token actually expired, return undefined
+      vi.advanceTimersByTime(14 * 1000);
+      result = SessionTokenCache.get(key);
+      expect(result).toBeUndefined();
+    });
 
-      vi.advanceTimersByTime(1 * 1000);
-      expect(SessionTokenCache.get(key)).toBeUndefined();
+    it('returns needsRefresh=true consistently while token is within leeway', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'dedupe-token',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { audience: 'dedupe-test', tokenId: 'dedupe-token' };
+
+      SessionTokenCache.set({ ...key, tokenResolver });
+      await tokenResolver;
+
+      // Advance to within leeway
+      vi.advanceTimersByTime(51 * 1000); // 9s remaining
+
+      // First call: needsRefresh=true
+      let result = SessionTokenCache.get(key);
+      expect(result?.needsRefresh).toBe(true);
+
+      // Second call: needsRefresh=true (consistently signals refresh needed)
+      result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('dedupe-token');
+      expect(result?.needsRefresh).toBe(true);
     });
 
-    it('enforces minimum 5 second sync leeway even when leeway is set to 0', async () => {
+    it('honors larger custom leeway values', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'custom-leeway-token',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { audience: 'custom-leeway-test', tokenId: 'custom-leeway-token' };
+
+      SessionTokenCache.set({ ...key, tokenResolver });
+      await tokenResolver;
+
+      // At 29s elapsed, 31s remaining - fresh with 30s leeway
+      vi.advanceTimersByTime(29 * 1000);
+      let result = SessionTokenCache.get(key, 30);
+      expect(result?.entry.tokenId).toBe('custom-leeway-token');
+      expect(result?.needsRefresh).toBe(false);
+
+      // At 31s elapsed, 29s remaining (< 30s leeway) - needs refresh
+      vi.advanceTimersByTime(2 * 1000);
+      result = SessionTokenCache.get(key, 30);
+      expect(result?.entry.tokenId).toBe('custom-leeway-token');
+      expect(result?.needsRefresh).toBe(true);
+    });
+
+    it('enforces minimum 15 second threshold even when leeway is set to 0', async () => {
       const nowSeconds = Math.floor(Date.now() / 1000);
       const jwt = createJwtWithTtl(nowSeconds, 60);
 
@@ -577,13 +668,167 @@ describe('SessionTokenCache', () => {
       SessionTokenCache.set({ ...key, tokenResolver });
       await tokenResolver;
 
-      expect(SessionTokenCache.get(key, 0)).toMatchObject({ tokenId: 'zero-leeway-token' });
+      // 16s remaining (above 15s threshold)
+      vi.advanceTimersByTime(44 * 1000);
+      let result = SessionTokenCache.get(key, 0);
+      expect(result?.entry.tokenId).toBe('zero-leeway-token');
+      expect(result?.needsRefresh).toBe(false);
+
+      // 14s remaining (below 15s threshold)
+      vi.advanceTimersByTime(2 * 1000);
+      result = SessionTokenCache.get(key, 0);
+      expect(result?.entry.tokenId).toBe('zero-leeway-token');
+      expect(result?.needsRefresh).toBe(true);
+
+      // 0s remaining (expired)
+      vi.advanceTimersByTime(14 * 1000);
+      result = SessionTokenCache.get(key, 0);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('conservative threshold behavior', () => {
+    it('returns needsRefresh=false when TTL is comfortably above 15s threshold', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'above-threshold-token',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { tokenId: 'above-threshold-token' };
+
+      SessionTokenCache.set({ ...key, tokenResolver });
+      await tokenResolver;
+
+      // 60s remaining
+      let result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('above-threshold-token');
+      expect(result?.needsRefresh).toBe(false);
+
+      // 20s remaining
+      vi.advanceTimersByTime(40 * 1000);
+      result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('above-threshold-token');
+      expect(result?.needsRefresh).toBe(false);
+    });
+
+    it('returns needsRefresh=true when TTL drops just below 15s threshold', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'below-threshold-token',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { tokenId: 'below-threshold-token' };
+
+      SessionTokenCache.set({ ...key, tokenResolver });
+      await tokenResolver;
+
+      // 16s remaining
+      vi.advanceTimersByTime(44 * 1000);
+      let result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('below-threshold-token');
+      expect(result?.needsRefresh).toBe(false);
 
+      // 14s remaining
+      vi.advanceTimersByTime(2 * 1000);
+      result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('below-threshold-token');
+      expect(result?.needsRefresh).toBe(true);
+    });
+
+    it('uses caller leeway when larger than 15s threshold', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'large-leeway-token',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { tokenId: 'large-leeway-token' };
+
+      SessionTokenCache.set({ ...key, tokenResolver });
+      await tokenResolver;
+
+      // 21s remaining (leeway=20s)
+      vi.advanceTimersByTime(39 * 1000);
+      let result = SessionTokenCache.get(key, 20);
+      expect(result?.entry.tokenId).toBe('large-leeway-token');
+      expect(result?.needsRefresh).toBe(false);
+
+      // 19s remaining (leeway=20s)
+      vi.advanceTimersByTime(2 * 1000);
+      result = SessionTokenCache.get(key, 20);
+      expect(result?.entry.tokenId).toBe('large-leeway-token');
+      expect(result?.needsRefresh).toBe(true);
+    });
+
+    it('ignores caller leeway when smaller than 15s threshold', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'small-leeway-token',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { tokenId: 'small-leeway-token' };
+
+      SessionTokenCache.set({ ...key, tokenResolver });
+      await tokenResolver;
+
+      // 16s remaining (leeway=5s, but min threshold is 15s)
+      vi.advanceTimersByTime(44 * 1000);
+      let result = SessionTokenCache.get(key, 5);
+      expect(result?.entry.tokenId).toBe('small-leeway-token');
+      expect(result?.needsRefresh).toBe(false);
+
+      // 14s remaining
+      vi.advanceTimersByTime(2 * 1000);
+      result = SessionTokenCache.get(key, 5);
+      expect(result?.entry.tokenId).toBe('small-leeway-token');
+      expect(result?.needsRefresh).toBe(true);
+    });
+
+    it('forces synchronous refresh when token has less than poller interval remaining', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'hard-cutoff-token',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { tokenId: 'hard-cutoff-token' };
+
+      SessionTokenCache.set({ ...key, tokenResolver });
+      await tokenResolver;
+
+      // 6s remaining (just above 5s cutoff)
       vi.advanceTimersByTime(54 * 1000);
-      expect(SessionTokenCache.get(key, 0)).toBeDefined();
+      let result = SessionTokenCache.get(key);
+      expect(result?.entry.tokenId).toBe('hard-cutoff-token');
+      expect(result?.needsRefresh).toBe(true);
 
+      // 4s remaining (below 5s cutoff) - forces sync refresh
       vi.advanceTimersByTime(2 * 1000);
-      expect(SessionTokenCache.get(key, 0)).toBeUndefined();
+      result = SessionTokenCache.get(key);
+      expect(result).toBeUndefined();
     });
   });
 
@@ -604,7 +849,7 @@ describe('SessionTokenCache', () => {
       SessionTokenCache.set({ ...key, tokenResolver });
       await tokenResolver;
 
-      expect(SessionTokenCache.get(key)).toBeDefined();
+      expect(SessionTokenCache.get(key)?.entry).toBeDefined();
 
       vi.advanceTimersByTime(30 * 1000);
 
@@ -627,10 +872,10 @@ describe('SessionTokenCache', () => {
       SessionTokenCache.set({ ...key, tokenResolver });
       await tokenResolver;
 
-      expect(SessionTokenCache.get(key)).toBeDefined();
+      expect(SessionTokenCache.get(key)?.entry).toBeDefined();
 
       vi.advanceTimersByTime(90 * 1000);
-      expect(SessionTokenCache.get(key)).toBeDefined();
+      expect(SessionTokenCache.get(key)?.entry).toBeDefined();
 
       vi.advanceTimersByTime(30 * 1000);
       expect(SessionTokenCache.get(key)).toBeUndefined();
@@ -656,7 +901,7 @@ describe('SessionTokenCache', () => {
         SessionTokenCache.set({ tokenId: label, tokenResolver });
         await tokenResolver;
 
-        expect(SessionTokenCache.get({ tokenId: label })).toBeDefined();
+        expect(SessionTokenCache.get({ tokenId: label })?.entry).toBeDefined();
 
         vi.advanceTimersByTime(ttl * 1000);
         expect(SessionTokenCache.get({ tokenId: label })).toBeUndefined();
@@ -684,9 +929,9 @@ describe('SessionTokenCache', () => {
       SessionTokenCache.set({ ...keyWithAudience, tokenResolver });
       await tokenResolver;
 
-      const cached = SessionTokenCache.get(keyWithAudience);
-      expect(cached).toBeDefined();
-      expect(cached?.audience).toBe('https://api.example.com');
+      const result = SessionTokenCache.get(keyWithAudience);
+      expect(result).toBeDefined();
+      expect(result?.entry.audience).toBe('https://api.example.com');
     });
 
     it('treats tokens with different audiences as separate entries', async () => {
@@ -709,8 +954,8 @@ describe('SessionTokenCache', () => {
       await Promise.all([resolver1, resolver2]);
 
       expect(SessionTokenCache.size()).toBe(2);
-      expect(SessionTokenCache.get(key1)).toBeDefined();
-      expect(SessionTokenCache.get(key2)).toBeDefined();
+      expect(SessionTokenCache.get(key1)?.entry).toBeDefined();
+      expect(SessionTokenCache.get(key2)?.entry).toBeDefined();
     });
   });
 
@@ -762,6 +1007,61 @@ describe('SessionTokenCache', () => {
     });
   });
 
+  describe('resolvedToken', () => {
+    it('is populated after tokenResolver resolves', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'resolved-token-test',
+        jwt,
+        object: 'token',
+      });
+
+      const tokenResolver = Promise.resolve<TokenResource>(token);
+      const key = { tokenId: 'resolved-token-test' };
+
+      SessionTokenCache.set({ ...key, tokenResolver });
+
+      // Before promise resolves, resolvedToken should be undefined
+      let result = SessionTokenCache.get(key);
+      expect(result?.entry.resolvedToken).toBeUndefined();
+
+      // Wait for promise to resolve
+      await tokenResolver;
+
+      // After promise resolves, resolvedToken should be populated
+      result = SessionTokenCache.get(key);
+      expect(result?.entry.resolvedToken).toBeDefined();
+      expect(result?.entry.resolvedToken?.getRawString()).toBeTruthy();
+    });
+
+    it('can be provided when setting a pre-resolved token', async () => {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      const jwt = createJwtWithTtl(nowSeconds, 60);
+
+      const token = new Token({
+        id: 'pre-resolved-token',
+        jwt,
+        object: 'token',
+      });
+
+      const key = { tokenId: 'pre-resolved-token' };
+
+      // Set with both tokenResolver and resolvedToken
+      SessionTokenCache.set({
+        ...key,
+        resolvedToken: token,
+        tokenResolver: Promise.resolve(token),
+      });
+
+      // resolvedToken should be immediately available
+      const result = SessionTokenCache.get(key);
+      expect(result?.entry.resolvedToken).toBeDefined();
+      expect(result?.entry.resolvedToken).toBe(token);
+    });
+  });
+
   describe('multi-session isolation', () => {
     it('stores tokens from different session IDs separately without interference', async () => {
       const nowSeconds = Math.floor(Date.now() / 1000);
@@ -813,15 +1113,15 @@ describe('SessionTokenCache', () => {
       // (not session2's token) - tokens are isolated by tokenId
       const retrievedSession1Token = SessionTokenCache.get({ tokenId: session1Id });
       expect(retrievedSession1Token).toBeDefined();
-      const resolvedSession1Token = await retrievedSession1Token!.tokenResolver;
+      const resolvedSession1Token = await retrievedSession1Token!.entry.tokenResolver;
       expect(resolvedSession1Token.jwt?.claims?.iat).toBe(nowSeconds);
-      expect(retrievedSession1Token!.tokenId).toBe(session1Id);
+      expect(retrievedSession1Token!.entry.tokenId).toBe(session1Id);
 
       // Verify session2's token is separate
       const retrievedSession2Token = SessionTokenCache.get({ tokenId: session2Id });
       expect(retrievedSession2Token).toBeDefined();
-      expect(retrievedSession2Token!.tokenId).toBe(session2Id);
-      expect(retrievedSession2Token!.tokenId).not.toBe(session1Id);
+      expect(retrievedSession2Token!.entry.tokenId).toBe(session2Id);
+      expect(retrievedSession2Token!.entry.tokenId).not.toBe(session1Id);
     });
 
     it('accepts broadcast messages from the same session ID', async () => {
@@ -847,7 +1147,7 @@ describe('SessionTokenCache', () => {
 
       const cachedToken = SessionTokenCache.get({ tokenId: sessionId });
       expect(cachedToken).toBeDefined();
-      const resolvedToken = await cachedToken!.tokenResolver;
+      const resolvedToken = await cachedToken!.entry.tokenResolver;
       expect(resolvedToken.jwt?.claims?.iat).toBe(nowSeconds - 10);
 
       const newerJwt = createJwtWithTtl(nowSeconds, 60);
@@ -867,7 +1167,7 @@ describe('SessionTokenCache', () => {
       await vi.waitFor(async () => {
         const updatedCached = SessionTokenCache.get({ tokenId: sessionId });
         expect(updatedCached).toBeDefined();
-        const updatedToken = await updatedCached!.tokenResolver;
+        const updatedToken = await updatedCached!.entry.tokenResolver;
         expect(updatedToken.jwt?.claims?.iat).toBe(nowSeconds);
       });
 
diff --git a/packages/clerk-js/src/core/auth/AuthCookieService.ts b/packages/clerk-js/src/core/auth/AuthCookieService.ts
index 51268dc6bcd..8c747871408 100644
--- a/packages/clerk-js/src/core/auth/AuthCookieService.ts
+++ b/packages/clerk-js/src/core/auth/AuthCookieService.ts
@@ -162,7 +162,8 @@ export class AuthCookieService {
     }
 
     try {
-      const token = await this.clerk.session.getToken();
+      // Use refreshIfStale to fetch fresh token when cached token is within leeway period
+      const token = await this.clerk.session.getToken({ refreshIfStale: true });
       if (updateCookieImmediately) {
         this.updateSessionCookie(token);
       }
diff --git a/packages/clerk-js/src/core/auth/SessionCookiePoller.ts b/packages/clerk-js/src/core/auth/SessionCookiePoller.ts
index 91e8040f79d..ed9f1f04c76 100644
--- a/packages/clerk-js/src/core/auth/SessionCookiePoller.ts
+++ b/packages/clerk-js/src/core/auth/SessionCookiePoller.ts
@@ -3,7 +3,8 @@ import { createWorkerTimers } from '@clerk/shared/workerTimers';
 import { SafeLock } from './safeLock';
 
 const REFRESH_SESSION_TOKEN_LOCK_KEY = 'clerk.lock.refreshSessionToken';
-const INTERVAL_IN_MS = 5 * 1_000;
+
+export const POLLER_INTERVAL_IN_MS = 5 * 1_000;
 
 export class SessionCookiePoller {
   private lock = SafeLock(REFRESH_SESSION_TOKEN_LOCK_KEY);
@@ -20,7 +21,7 @@ export class SessionCookiePoller {
     const run = async () => {
       this.initiated = true;
       await this.lock.acquireLockAndRun(cb);
-      this.timerId = this.workerTimers.setTimeout(run, INTERVAL_IN_MS);
+      this.timerId = this.workerTimers.setTimeout(run, POLLER_INTERVAL_IN_MS);
     };
 
     void run();
diff --git a/packages/clerk-js/src/core/resources/Session.ts b/packages/clerk-js/src/core/resources/Session.ts
index d49aefd2186..6d0f96bc1ee 100644
--- a/packages/clerk-js/src/core/resources/Session.ts
+++ b/packages/clerk-js/src/core/resources/Session.ts
@@ -350,7 +350,7 @@ export class Session extends BaseResource implements SessionResource {
       return null;
     }
 
-    const { leewayInSeconds, template, skipCache = false } = options || {};
+    const { leewayInSeconds, refreshIfStale = false, skipCache = false, template } = options || {};
 
     // If no organization ID is provided, default to the selected organization in memory
     // Note: this explicitly allows passing `null` or `""`, which should select the personal workspace.
@@ -363,59 +363,71 @@ export class Session extends BaseResource implements SessionResource {
 
     const tokenId = this.#getCacheId(template, organizationId);
 
-    const cachedEntry = skipCache ? undefined : SessionTokenCache.get({ tokenId }, leewayInSeconds);
+    const cacheResult = skipCache ? undefined : SessionTokenCache.get({ tokenId }, leewayInSeconds);
 
     // Dispatch tokenUpdate only for __session tokens with the session's active organization ID, and not JWT templates
     const shouldDispatchTokenUpdate = !template && organizationId === this.lastActiveOrganizationId;
 
-    if (cachedEntry) {
-      debugLogger.debug(
-        'Using cached token (no fetch needed)',
-        {
-          tokenId,
-        },
-        'session',
-      );
-      const cachedToken = await cachedEntry.tokenResolver;
+    if (cacheResult) {
+      // If caller requests refresh when stale (e.g., poller), fetch fresh token instead of returning cached
+      if (cacheResult.needsRefresh && refreshIfStale) {
+        debugLogger.debug('Token is stale, refreshing as requested', { tokenId }, 'session');
+        return this.#fetchToken(template, organizationId, tokenId, shouldDispatchTokenUpdate);
+      }
+
+      debugLogger.debug('Using cached token', { tokenId }, 'session');
+
+      // Prefer synchronous read to avoid microtask overhead when token is already resolved
+      const cachedToken = cacheResult.entry.resolvedToken ?? (await cacheResult.entry.tokenResolver);
       if (shouldDispatchTokenUpdate) {
         eventBus.emit(events.TokenUpdate, { token: cachedToken });
       }
-      // Return null when raw string is empty to indicate that there it's signed-out
+      // Return null when raw string is empty to indicate signed-out state
       return cachedToken.getRawString() || null;
     }
 
-    debugLogger.info(
-      'Fetching new token from API',
-      {
-        organizationId,
-        template,
-        tokenId,
-      },
-      'session',
-    );
+    return this.#fetchToken(template, organizationId, tokenId, shouldDispatchTokenUpdate);
+  }
 
+  #createTokenResolver(
+    template: string | undefined,
+    organizationId: string | undefined | null,
+  ): Promise<TokenResource> {
     const path = template ? `${this.path()}/tokens/${template}` : `${this.path()}/tokens`;
-
     // TODO: update template endpoint to accept organizationId
-    const params: Record<string, string | null> = template ? {} : { organizationId };
+    const params: Record<string, string | null> = template ? {} : { organizationId: organizationId ?? null };
+    return Token.create(path, params, false);
+  }
+
+  #dispatchTokenEvents(token: TokenResource, shouldDispatch: boolean): void {
+    if (!shouldDispatch) {
+      return;
+    }
 
-    const tokenResolver = Token.create(path, params, skipCache);
+    eventBus.emit(events.TokenUpdate, { token });
+
+    if (token.jwt) {
+      this.lastActiveToken = token;
+      eventBus.emit(events.SessionTokenResolved, null);
+    }
+  }
+
+  #fetchToken(
+    template: string | undefined,
+    organizationId: string | undefined | null,
+    tokenId: string,
+    shouldDispatchTokenUpdate: boolean,
+  ): Promise<string | null> {
+    debugLogger.info('Fetching new token from API', { organizationId, template, tokenId }, 'session');
+
+    const tokenResolver = this.#createTokenResolver(template, organizationId);
 
     // Cache the promise immediately to prevent concurrent calls from triggering duplicate requests
     SessionTokenCache.set({ tokenId, tokenResolver });
 
     return tokenResolver.then(token => {
-      if (shouldDispatchTokenUpdate) {
-        eventBus.emit(events.TokenUpdate, { token });
-
-        if (token.jwt) {
-          this.lastActiveToken = token;
-          // Emits the updated session with the new token to the state listeners
-          eventBus.emit(events.SessionTokenResolved, null);
-        }
-      }
-
-      // Return null when raw string is empty to indicate that there it's signed-out
+      this.#dispatchTokenEvents(token, shouldDispatchTokenUpdate);
+      // Return null when raw string is empty to indicate signed-out state
       return token.getRawString() || null;
     });
   }
diff --git a/packages/clerk-js/src/core/resources/__tests__/Session.test.ts b/packages/clerk-js/src/core/resources/__tests__/Session.test.ts
index 4de20208046..84bd67bfabd 100644
--- a/packages/clerk-js/src/core/resources/__tests__/Session.test.ts
+++ b/packages/clerk-js/src/core/resources/__tests__/Session.test.ts
@@ -100,7 +100,7 @@ describe('Session', () => {
       expect(dispatchSpy).toHaveBeenCalledTimes(2);
     });
 
-    it('does not re-cache token when Session is reconstructed with same token', async () => {
+    it('returns same token without API call when Session is reconstructed', async () => {
       BaseResource.clerk = clerkMock({
         organization: new Organization({ id: 'activeOrganization' } as OrganizationJSON),
       });
@@ -119,10 +119,6 @@ describe('Session', () => {
         updated_at: new Date().getTime(),
       } as SessionJSON);
 
-      expect(SessionTokenCache.size()).toBe(1);
-      const cachedEntry1 = SessionTokenCache.get({ tokenId: 'session_1-activeOrganization' });
-      expect(cachedEntry1).toBeDefined();
-
       const session2 = new Session({
         status: 'active',
         id: 'session_1',
@@ -135,8 +131,6 @@ describe('Session', () => {
         updated_at: new Date().getTime(),
       } as SessionJSON);
 
-      expect(SessionTokenCache.size()).toBe(1);
-
       const token1 = await session1.getToken();
       const token2 = await session2.getToken();
 
@@ -145,12 +139,12 @@ describe('Session', () => {
       expect(BaseResource.clerk.getFapiClient().request).not.toHaveBeenCalled();
     });
 
-    it('caches token from cookie during degraded mode recovery', async () => {
+    it('returns lastActiveToken without API call (degraded mode recovery)', async () => {
       BaseResource.clerk = clerkMock();
 
       SessionTokenCache.clear();
 
-      const sessionFromCookie = new Session({
+      const session = new Session({
         status: 'active',
         id: 'session_1',
         object: 'session',
@@ -162,11 +156,8 @@ describe('Session', () => {
         updated_at: new Date().getTime(),
       } as SessionJSON);
 
-      expect(SessionTokenCache.size()).toBe(1);
-      const cachedEntry = SessionTokenCache.get({ tokenId: 'session_1' });
-      expect(cachedEntry).toBeDefined();
+      const token = await session.getToken();
 
-      const token = await sessionFromCookie.getToken();
       expect(token).toEqual(mockJwt);
       expect(BaseResource.clerk.getFapiClient().request).not.toHaveBeenCalled();
     });
@@ -426,6 +417,165 @@ describe('Session', () => {
 
       expect(requestSpy).toHaveBeenCalledTimes(2);
     });
+
+    describe('stale-while-revalidate (SWR) behavior', () => {
+      it('returns stale token immediately while refreshing in background', async () => {
+        BaseResource.clerk = clerkMock();
+        const requestSpy = BaseResource.clerk.getFapiClient().request as Mock<any>;
+
+        const session = new Session({
+          status: 'active',
+          id: 'session_1',
+          object: 'session',
+          user: createUser({}),
+          last_active_organization_id: null,
+          last_active_token: { object: 'token', jwt: mockJwt },
+          actor: null,
+          created_at: new Date().getTime(),
+          updated_at: new Date().getTime(),
+        } as SessionJSON);
+
+        await Promise.resolve();
+
+        // Advance time so token needs refresh (< 15s remaining of 60s TTL)
+        vi.advanceTimersByTime(46 * 1000);
+
+        // Hold the network request pending
+        let resolveNetworkRequest!: (value: any) => void;
+        requestSpy.mockClear();
+        requestSpy.mockReturnValueOnce(
+          new Promise(resolve => {
+            resolveNetworkRequest = resolve;
+          }),
+        );
+
+        // Concurrent calls should all return immediately with stale token
+        const [token1, token2, token3] = await Promise.all([
+          session.getToken(),
+          session.getToken(),
+          session.getToken(),
+        ]);
+
+        expect(token1).toEqual(mockJwt);
+        expect(token2).toEqual(mockJwt);
+        expect(token3).toEqual(mockJwt);
+        expect(requestSpy).toHaveBeenCalledTimes(1);
+
+        // Cleanup: resolve the pending request
+        resolveNetworkRequest({ payload: { object: 'token', jwt: mockJwt }, status: 200 });
+        await vi.advanceTimersByTimeAsync(0);
+      });
+
+      it('continues returning tokens after background refresh failure', async () => {
+        BaseResource.clerk = clerkMock();
+        const requestSpy = BaseResource.clerk.getFapiClient().request as Mock<any>;
+
+        const session = new Session({
+          status: 'active',
+          id: 'session_1',
+          object: 'session',
+          user: createUser({}),
+          last_active_organization_id: null,
+          last_active_token: { object: 'token', jwt: mockJwt },
+          actor: null,
+          created_at: new Date().getTime(),
+          updated_at: new Date().getTime(),
+        } as SessionJSON);
+
+        await Promise.resolve();
+        vi.advanceTimersByTime(46 * 1000);
+
+        // Background refresh fails
+        requestSpy.mockClear();
+        requestSpy.mockRejectedValueOnce(new Error('Network error'));
+
+        const token = await session.getToken();
+        expect(token).toEqual(mockJwt);
+
+        // Wait for background failure to complete
+        await vi.advanceTimersByTimeAsync(100);
+
+        // Subsequent call should still return token (stale is preserved)
+        const token2 = await session.getToken();
+        expect(token2).toEqual(mockJwt);
+      });
+
+      it('retries background refresh after previous failure', async () => {
+        BaseResource.clerk = clerkMock();
+        const requestSpy = BaseResource.clerk.getFapiClient().request as Mock<any>;
+
+        const session = new Session({
+          status: 'active',
+          id: 'session_1',
+          object: 'session',
+          user: createUser({}),
+          last_active_organization_id: null,
+          last_active_token: { object: 'token', jwt: mockJwt },
+          actor: null,
+          created_at: new Date().getTime(),
+          updated_at: new Date().getTime(),
+        } as SessionJSON);
+
+        await Promise.resolve();
+        vi.advanceTimersByTime(46 * 1000);
+
+        // First call triggers background refresh that fails
+        requestSpy.mockClear();
+        requestSpy.mockRejectedValueOnce(new Error('Network error'));
+
+        await session.getToken();
+        expect(requestSpy).toHaveBeenCalledTimes(1);
+
+        await vi.advanceTimersByTimeAsync(100);
+
+        // Second call should trigger another refresh attempt
+        requestSpy.mockClear();
+        requestSpy.mockResolvedValueOnce({ payload: { object: 'token', jwt: mockJwt }, status: 200 });
+
+        await session.getToken();
+        expect(requestSpy).toHaveBeenCalledTimes(1);
+      });
+
+      it('uses refreshed token for subsequent calls after background refresh succeeds', async () => {
+        BaseResource.clerk = clerkMock();
+        const requestSpy = BaseResource.clerk.getFapiClient().request as Mock<any>;
+
+        const newMockJwt =
+          'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2NjY2NDg0MDAsImlhdCI6MTY2NjY0ODM0MCwiaXNzIjoiaHR0cHM6Ly9jbGVyay5leGFtcGxlLmNvbSIsImp0aSI6Im5ld3Rva2VuIiwibmJmIjoxNjY2NjQ4MzQwLCJzaWQiOiJzZXNzXzFxcTlveTVHaU5IeGRSMlhXVTZnRzZtSWNCWCIsInN1YiI6InVzZXJfMXFxOW95NUdpTkh4ZFIyWFdVNmdHNm1JY0JYIn0.mock';
+
+        const session = new Session({
+          status: 'active',
+          id: 'session_1',
+          object: 'session',
+          user: createUser({}),
+          last_active_organization_id: null,
+          last_active_token: { object: 'token', jwt: mockJwt },
+          actor: null,
+          created_at: new Date().getTime(),
+          updated_at: new Date().getTime(),
+        } as SessionJSON);
+
+        await Promise.resolve();
+        vi.advanceTimersByTime(46 * 1000);
+
+        // Background refresh returns new token
+        requestSpy.mockClear();
+        requestSpy.mockResolvedValueOnce({ payload: { object: 'token', jwt: newMockJwt }, status: 200 });
+
+        // First call returns stale token
+        const staleToken = await session.getToken();
+        expect(staleToken).toEqual(mockJwt);
+
+        // Wait for background refresh to complete
+        await vi.advanceTimersByTimeAsync(100);
+
+        // Subsequent call returns refreshed token (no new API call needed)
+        requestSpy.mockClear();
+        const freshToken = await session.getToken();
+        expect(freshToken).toEqual(newMockJwt);
+        expect(requestSpy).not.toHaveBeenCalled();
+      });
+    });
   });
 
   describe('touch()', () => {
diff --git a/packages/clerk-js/src/core/tokenCache.ts b/packages/clerk-js/src/core/tokenCache.ts
index 74697b80c63..418167aea46 100644
--- a/packages/clerk-js/src/core/tokenCache.ts
+++ b/packages/clerk-js/src/core/tokenCache.ts
@@ -3,6 +3,7 @@ import type { TokenResource } from '@clerk/shared/types';
 import { debugLogger } from '@/utils/debug';
 import { TokenId } from '@/utils/tokenId';
 
+import { POLLER_INTERVAL_IN_MS } from './auth/SessionCookiePoller';
 import { Token } from './resources/internal';
 
 /**
@@ -23,6 +24,11 @@ interface TokenCacheEntry extends TokenCacheKeyJSON {
    * Used for expiration and cleanup scheduling.
    */
   createdAt?: Seconds;
+  /**
+   * The resolved token value for synchronous reads.
+   * Populated after tokenResolver resolves. Check this first to avoid microtask overhead.
+   */
+  resolvedToken?: TokenResource;
   /**
    * Promise that resolves to the TokenResource.
    * May be pending and should be awaited before accessing token data.
@@ -42,6 +48,15 @@ interface TokenCacheValue {
   timeoutId?: ReturnType<typeof setTimeout>;
 }
 
+/**
+ * Result from cache lookup containing the entry and refresh status.
+ */
+export interface TokenCacheGetResult {
+  entry: TokenCacheEntry;
+  /** Indicates the token is valid but expiring soon and should be refreshed in the background */
+  needsRefresh: boolean;
+}
+
 export interface TokenCache {
   /**
    * Removes all cached entries and clears associated timeouts.
@@ -56,13 +71,15 @@ export interface TokenCache {
   close(): void;
 
   /**
-   * Retrieves a cached token entry if it exists and has not expired.
+   * Retrieves a cached token entry if it exists and is safe to use.
+   * Implements stale-while-revalidate: returns valid tokens immediately and signals when background refresh is needed.
+   * Forces synchronous refresh if token has less than one poller interval remaining.
    *
    * @param cacheKeyJSON - Object containing tokenId and optional audience to identify the cached entry
-   * @param leeway - Optional seconds before expiration to treat token as expired (default: 10s). Combined with 5s sync leeway.
-   * @returns The cached TokenCacheEntry if found and valid, undefined otherwise
+   * @param leeway - Seconds before expiration to trigger background refresh (default: 10s). Minimum is 15s.
+   * @returns Result with entry and refresh flag, or undefined if token is missing/expired/too close to expiration
    */
-  get(cacheKeyJSON: TokenCacheKeyJSON, leeway?: number): TokenCacheEntry | undefined;
+  get(cacheKeyJSON: TokenCacheKeyJSON, leeway?: number): TokenCacheGetResult | undefined;
 
   /**
    * Stores a token entry in the cache and broadcasts to other tabs when the token resolves.
@@ -82,9 +99,13 @@ export interface TokenCache {
 
 const KEY_PREFIX = 'clerk';
 const DELIMITER = '::';
-const LEEWAY = 10;
-// This value should have the same value as the INTERVAL_IN_MS in SessionCookiePoller
-const SYNC_LEEWAY = 5;
+const DEFAULT_LEEWAY = 10;
+
+/**
+ * Conservative threshold accounting for timer jitter, SafeLock contention (~5s),
+ * network latency, and tolerance for missed poller ticks.
+ */
+const MIN_REMAINING_TTL_IN_SECONDS = 15;
 
 const BROADCAST = { broadcast: true };
 const NO_BROADCAST = { broadcast: false };
@@ -174,7 +195,7 @@ const MemoryTokenCache = (prefix = KEY_PREFIX): TokenCache => {
     cache.clear();
   };
 
-  const get = (cacheKeyJSON: TokenCacheKeyJSON, leeway = LEEWAY): TokenCacheEntry | undefined => {
+  const get = (cacheKeyJSON: TokenCacheKeyJSON, leeway = DEFAULT_LEEWAY): TokenCacheGetResult | undefined => {
     ensureBroadcastChannel();
 
     const cacheKey = new TokenCacheKey(prefix, cacheKeyJSON);
@@ -186,13 +207,10 @@ const MemoryTokenCache = (prefix = KEY_PREFIX): TokenCache => {
 
     const nowSeconds = Math.floor(Date.now() / 1000);
     const elapsed = nowSeconds - value.createdAt;
+    const remainingTtl = (value.expiresIn ?? Infinity) - elapsed;
 
-    // Include poller interval as part of the leeway to ensure the cache value
-    // will be valid for more than the SYNC_LEEWAY or the leeway in the next poll.
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const expiresSoon = value.expiresIn! - elapsed < (leeway || 1) + SYNC_LEEWAY;
-
-    if (expiresSoon) {
+    // Token expired or dangerously close to expiration - force synchronous refresh
+    if (remainingTtl <= POLLER_INTERVAL_IN_MS / 1000) {
       if (value.timeoutId !== undefined) {
         clearTimeout(value.timeoutId);
       }
@@ -200,7 +218,13 @@ const MemoryTokenCache = (prefix = KEY_PREFIX): TokenCache => {
       return;
     }
 
-    return value.entry;
+    const effectiveLeeway = Math.max(leeway, MIN_REMAINING_TTL_IN_SECONDS);
+
+    // Token is valid but expiring soon - signal that refresh is needed
+    const needsRefresh = remainingTtl < effectiveLeeway;
+
+    // Return the valid token immediately, caller decides whether to refresh
+    return { entry: value.entry, needsRefresh };
   };
 
   /**
@@ -249,9 +273,9 @@ const MemoryTokenCache = (prefix = KEY_PREFIX): TokenCache => {
     }
 
     try {
-      const existingEntry = get({ tokenId: data.tokenId });
-      if (existingEntry) {
-        const existingToken = await existingEntry.tokenResolver;
+      const result = get({ tokenId: data.tokenId });
+      if (result) {
+        const existingToken = await result.entry.tokenResolver;
         const existingIat = existingToken.jwt?.claims?.iat;
         if (existingIat && existingIat >= iat) {
           debugLogger.debug(
@@ -330,6 +354,9 @@ const MemoryTokenCache = (prefix = KEY_PREFIX): TokenCache => {
 
     entry.tokenResolver
       .then(newToken => {
+        // Store resolved token for synchronous reads
+        entry.resolvedToken = newToken;
+
         const claims = newToken.jwt?.claims;
         if (!claims || typeof claims.exp !== 'number' || typeof claims.iat !== 'number') {
           return deleteKey();
diff --git a/packages/shared/src/types/session.ts b/packages/shared/src/types/session.ts
index 727c044ad48..13cb2a39449 100644
--- a/packages/shared/src/types/session.ts
+++ b/packages/shared/src/types/session.ts
@@ -339,10 +339,16 @@ export interface SessionTask {
 }
 
 export type GetTokenOptions = {
-  template?: string;
-  organizationId?: string;
   leewayInSeconds?: number;
+  organizationId?: string;
+  /**
+   * @internal
+   * When true, forces a fresh token fetch if the cached token is within the refresh leeway period.
+   * Used by the token poller to proactively refresh tokens before they expire.
+   */
+  refreshIfStale?: boolean;
   skipCache?: boolean;
+  template?: string;
 };
 /**
  * @inline