@@ -6,6 +6,15 @@
 
 Work in this release was contributed by @psh4607, @trinitiwowka, @nehaprasad-dev, and @JealousGx. Thank you for your contributions!
 
+- feat(cloudflare): Add `experimental.cacheClient` to reuse one client across invocations ([#TODO](https://github.com/getsentry/sentry-javascript/pull/TODO)). Opting in reuses a single client per isolate instead of building and disposing one per invocation, which removes that per-invocation cost and makes Durable Object telemetry reliable: a Durable Object has no `waitUntil` boundary that dependably extends execution, so with a per-invocation client anything captured after the handler returned was lost. Since a reused client never reaches an end-of-invocation flush, captured data is delivered eagerly instead.
+
+  ```js
+  Sentry.init({
+    dsn: env.SENTRY_DSN,
+    experimental: { cacheClient: true },
+  });
+  ```
+
 - fix(cloudflare): Stop Durable Object scope data leaking between invocations ([#TODO](https://github.com/getsentry/sentry-javascript/pull/TODO)). Instrumented Durable Object methods forked only the current scope, while `setUser`/`setTag` write to the isolation scope — which a Durable Object keeps across invocations. A user set while handling one invocation could therefore be attached to later invocations' events in the same isolate.
 
 - feat(deno)!: Rename several default integrations to match the other SDKs ([#22404](https://github.com/getsentry/sentry-javascript/pull/22404)). The `deno*Integration` exports are kept as deprecated aliases. If you were relying on the names (for example, to disable them), then note that these have changed:
 
@@ -0,0 +1,180 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+  SENTRY_DSN: string;
+  CACHE_DO: DurableObjectNamespace;
+  NO_CACHE_DO: DurableObjectNamespace;
+}
+
+function startDetachedWork(message: string): string {
+  void (async () => {
+    await new Promise(r => setTimeout(r, 3000));
+    Sentry.logger.info(`Detached log: ${message}`);
+    Sentry.captureException(new Error(message));
+  })();
+  return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+  async handlerError(instanceId: string): Promise<void> {
+    throw new Error(`Cache DO handler error from ${instanceId}`);
+  }
+
+  async dedupe(): Promise<string> {
+    Sentry.captureException(new Error('Same error'));
+    return 'dedupe test';
+  }
+
+  async scopeCheck(seed: boolean): Promise<string> {
+    if (seed) {
+      Sentry.setTag('seeded_tag', 'from-seeding-call');
+      Sentry.setUser({ id: 'user-from-seeding-call' });
+    }
+    Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+    return 'ok';
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    if (url.pathname === '/detached') {
+      return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+    }
+    if (url.pathname === '/streaming') {
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode('chunk1'));
+          controller.enqueue(new TextEncoder().encode('chunk2'));
+          controller.close();
+        },
+      });
+      return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+    }
+    return new Response('Cache DO');
+  }
+}
+
+// DO with cacheClient: false (default) — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+  async handlerError(instanceId: string): Promise<void> {
+    throw new Error(`No-cache DO handler error from ${instanceId}`);
+  }
+
+  async scopeCheck(seed: boolean): Promise<string> {
+    if (seed) {
+      Sentry.setTag('seeded_tag', 'from-seeding-call');
+      Sentry.setUser({ id: 'user-from-seeding-call' });
+    }
+    Sentry.captureException(new Error(seed ? 'No-cache scope seed' : 'No-cache scope probe'));
+    return 'ok';
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    if (url.pathname === '/detached') {
+      return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+    }
+    return new Response('No-cache DO');
+  }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    tracesSampleRate: 1,
+    enableLogs: true,
+    experimental: { cacheClient: true },
+    enableRpcTracePropagation: true,
+  }),
+  CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    tracesSampleRate: 1,
+    experimental: { cacheClient: false },
+    enableRpcTracePropagation: true,
+  }),
+  NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    tracesSampleRate: 1,
+    enableLogs: true,
+    experimental: { cacheClient: true },
+    enableRpcTracePropagation: true,
+  }),
+  {
+    async fetch(request, env) {
+      const url = new URL(request.url);
+      const instanceId = url.searchParams.get('id') || 'default';
+
+      // Cache DO RPC calls
+      if (url.pathname === '/cache/handler-error') {
+        const stub = env.CACHE_DO.get(
+          env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+        ) as DurableObjectStub<CacheDurableObjectBase>;
+        await stub.handlerError(instanceId);
+      }
+
+      if (url.pathname === '/cache/dedupe') {
+        const stub = env.CACHE_DO.get(
+          env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+        ) as DurableObjectStub<CacheDurableObjectBase>;
+        const result = await stub.dedupe();
+        return new Response(String(result));
+      }
+
+      if (url.pathname === '/cache/scope') {
+        const stub = env.CACHE_DO.get(
+          env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+        ) as DurableObjectStub<CacheDurableObjectBase>;
+        return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+      }
+
+      // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+      // since the DO fetch handler always initializes the DO's own client
+      if (url.pathname === '/cache/detached') {
+        const stub = env.CACHE_DO.get(
+          env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+        ) as DurableObjectStub<CacheDurableObjectBase>;
+        return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+      }
+
+      if (url.pathname === '/cache/streaming') {
+        const stub = env.CACHE_DO.get(
+          env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+        ) as DurableObjectStub<CacheDurableObjectBase>;
+        return stub.fetch(new Request('http://do/streaming'));
+      }
+
+      if (url.pathname === '/no-cache/scope') {
+        const stub = env.NO_CACHE_DO.get(
+          env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+        ) as DurableObjectStub<NoCacheDurableObjectBase>;
+        return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+      }
+
+      // No-cache DO calls
+      if (url.pathname === '/no-cache/handler-error') {
+        const stub = env.NO_CACHE_DO.get(
+          env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+        ) as DurableObjectStub<NoCacheDurableObjectBase>;
+        await stub.handlerError(instanceId);
+      }
+
+      if (url.pathname === '/no-cache/detached') {
+        const stub = env.NO_CACHE_DO.get(
+          env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+        ) as DurableObjectStub<NoCacheDurableObjectBase>;
+        return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+      }
+
+      return new Response('Hello World!');
+    },
+  } satisfies ExportedHandler<Env>,
+);
@@ -0,0 +1,185 @@
+import type { Envelope, Event } from '@sentry/core';
+import { expect, it } from 'vitest';
+import { createRunner } from '../../runner';
+
+type Mechanism = { type: string; handled: boolean };
+
+/**
+ * Matches an error event by exception value and capture mechanism.
+ *
+ * Callback-style (instead of exact `eventEnvelope` matching) because Durable Object
+ * RPC events carry no `request` and their trace context varies with propagation —
+ * only the exception payload is stable. Non-matching envelopes (worker-side duplicate
+ * captures, transactions) are dropped by the runner's unordered mode.
+ */
+function errorEventExpectation(value: string, mechanism: Mechanism) {
+  return (envelope: Envelope) => {
+    const event = envelope[1]?.[0]?.[1] as Event;
+    expect(event).toEqual(
+      expect.objectContaining({
+        level: 'error',
+        exception: {
+          values: [
+            expect.objectContaining({
+              type: 'Error',
+              value,
+              stacktrace: { frames: expect.any(Array) },
+              mechanism,
+            }),
+          ],
+        },
+      }),
+    );
+  };
+}
+
+const DO_MECHANISM: Mechanism = { type: 'auto.faas.cloudflare.durable_object', handled: false };
+// Direct `captureException` calls (not routed through a wrapped handler) always get this mechanism
+const CAPTURE_MECHANISM: Mechanism = { type: 'generic', handled: true };
+
+it('cacheClient: false - DO handler error is captured', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .expect(errorEventExpectation('No-cache DO handler error from instance-1', DO_MECHANISM))
+    .expect(errorEventExpectation('No-cache DO handler error from instance-2', DO_MECHANISM))
+    .unordered()
+    .start(signal);
+
+  await runner.makeRequest('get', '/no-cache/handler-error?id=instance-1', { expectError: true });
+  await runner.makeRequest('get', '/no-cache/handler-error?id=instance-2', { expectError: true });
+  await runner.completed();
+});
+
+it('cacheClient: true - DO handler error is captured', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .expect(errorEventExpectation('Cache DO handler error from instance-1', DO_MECHANISM))
+    .expect(errorEventExpectation('Cache DO handler error from instance-2', DO_MECHANISM))
+    .unordered()
+    .start(signal);
+
+  await runner.makeRequest('get', '/cache/handler-error?id=instance-1', { expectError: true });
+  await runner.makeRequest('get', '/cache/handler-error?id=instance-2', { expectError: true });
+  await runner.completed();
+});
+
+it('cacheClient: true - detached work events ARE captured', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .expect(errorEventExpectation('Detached work from cache DO instance-1', CAPTURE_MECHANISM))
+    .expect(errorEventExpectation('Detached work from cache DO instance-2', CAPTURE_MECHANISM))
+    // Logs batch client-side and the idle drain timer is disabled for this runtime, so a
+    // log only ever becomes an envelope if the cached client drains its log buffer on
+    // capture. Without that, detached logs are silently dropped while errors still arrive.
+    .expect((envelope: Envelope) => {
+      const payload = envelope[1]?.[0]?.[1] as { items?: Array<{ body?: string }> };
+      expect(payload.items?.some(log => log.body?.startsWith('Detached log: Detached work from cache DO'))).toBe(true);
+    })
+    .unordered()
+    .start(signal);
+
+  await runner.makeRequest('get', '/cache/detached?id=instance-1');
+  await runner.makeRequest('get', '/cache/detached?id=instance-2');
+  await runner.completed();
+});
+
+it('cacheClient: false - repro #22545: detached work events are silently dropped', async ({ signal }) => {
+  const runner = createRunner(__dirname).ignore('transaction').start(signal);
+
+  // Make the request that spawns detached work
+  await runner.makeRequest('get', '/no-cache/detached?id=repro-1');
+
+  // With cacheClient: false, the client is disposed after the handler returns,
+  // so the detached work's captureException (3s later) is silently dropped.
+  // We verify by waiting for the event with a timeout — if it doesn't arrive,
+  // the event was silently dropped as expected.
+  const result = await Promise.race([
+    runner.makeRequestAndWaitForEnvelope('get', '/no-cache/detached?id=repro-2', () => {
+      throw new Error('Received an event that should have been dropped with cacheClient: false');
+    }),
+    // Timeout: resolve with 'timeout' if no event arrives within 5s
+    new Promise<string>(resolve => setTimeout(() => resolve('timeout'), 5000)),
+  ]);
+
+  // The event should NOT have been received (timeout should win the race)
+  expect(result).toBe('timeout');
+});
+
+it('cacheClient: true - dedupe reports the same error in each separate invocation', async ({ signal }) => {
+  // A shared client shares its dedupe state too. RPC methods are wrapped with `withScope`,
+  // which forks the current scope but leaves the isolation scope shared, so dedupe cannot
+  // key on the isolation scope alone: three calls into the same Durable Object would report
+  // only the first error and silently drop the rest, unlike an uncached client.
+  const runner = createRunner(__dirname).ignore('transaction').start(signal);
+
+  for (let i = 0; i < 3; i++) {
+    await runner.makeRequestAndWaitForEnvelope(
+      'get',
+      '/cache/dedupe?id=dedupe-shared',
+      errorEventExpectation('Same error', CAPTURE_MECHANISM),
+    );
+  }
+});
+
+/**
+ * Seeds `setTag`/`setUser` in one Durable Object invocation, then asserts a later invocation of the
+ * same instance reports neither. Both write to the isolation scope, which a Durable Object keeps
+ * across invocations, so wrapped methods have to fork it — and disposing the client at the
+ * invocation boundary does not reset it, which is why this has to hold with caching either way.
+ */
+async function expectNoScopeLeak(signal: AbortSignal, route: string, label: string): Promise<void> {
+  const runner = createRunner(__dirname).ignore('transaction').start(signal);
+
+  await runner.makeRequestAndWaitForEnvelope('get', `${route}?id=scope-shared&seed=1`, (envelope: Envelope) => {
+    const event = envelope[1]?.[0]?.[1] as Event;
+    expect(event.exception?.values?.[0]?.value).toBe(`${label} scope seed`);
+    expect(event.tags).toEqual(expect.objectContaining({ seeded_tag: 'from-seeding-call' }));
+    expect(event.user).toEqual({ id: 'user-from-seeding-call' });
+  });
+
+  await runner.makeRequestAndWaitForEnvelope('get', `${route}?id=scope-shared&seed=0`, (envelope: Envelope) => {
+    const event = envelope[1]?.[0]?.[1] as Event;
+    expect(event.exception?.values?.[0]?.value).toBe(`${label} scope probe`);
+    expect(event.tags?.seeded_tag).toBeUndefined();
+    expect(event.user).toBeUndefined();
+  });
+}
+
+it('cacheClient: true - scope data does not leak into the next invocation', async ({ signal }) => {
+  await expectNoScopeLeak(signal, '/cache/scope', 'Cache');
+});
+
+it('cacheClient: false - scope data does not leak into the next invocation', async ({ signal }) => {
+  await expectNoScopeLeak(signal, '/no-cache/scope', 'No-cache');
+});
+
+it('cacheClient: true - streaming response works with shared client', async ({ signal }) => {
+  const transactionExpectation = (envelope: Envelope) => {
+    const tx = envelope[1]?.[0]?.[1] as Event;
+    expect(tx.transaction).toBe('GET /streaming');
+  };
+
+  const runner = createRunner(__dirname)
+    .expect(transactionExpectation)
+    .expect(transactionExpectation)
+    .unordered()
+    .start(signal);
+
+  const text1 = await runner.makeRequest<string>('get', '/cache/streaming');
+  expect(text1).toBe('chunk1chunk2');
+
+  const text2 = await runner.makeRequest<string>('get', '/cache/streaming');
+  expect(text2).toBe('chunk1chunk2');
+
+  await runner.completed();
+});
+
+it('cacheClient: true - multiple DO instances share the same client', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .expect(errorEventExpectation('Cache DO handler error from instance-1', DO_MECHANISM))
+    .expect(errorEventExpectation('Cache DO handler error from instance-2', DO_MECHANISM))
+    .unordered()
+    .start(signal);
+
+  // Two different DO instances — both should capture errors
+  await runner.makeRequest('get', '/cache/handler-error?id=instance-1', { expectError: true });
+  await runner.makeRequest('get', '/cache/handler-error?id=instance-2', { expectError: true });
+  await runner.completed();
+});