diff --git a/dev-packages/e2e-tests/test-applications/tanstackstart-react/tests/tunnel.test.ts b/dev-packages/e2e-tests/test-applications/tanstackstart-react/tests/tunnel.test.ts
index d42510f36173..b845965f5caf 100644
--- a/dev-packages/e2e-tests/test-applications/tanstackstart-react/tests/tunnel.test.ts
+++ b/dev-packages/e2e-tests/test-applications/tanstackstart-react/tests/tunnel.test.ts
@@ -61,15 +61,6 @@ test('Sends client-side errors through the configured tunnel route', async ({ pa
   expect(errorEvent.transaction).toBe(`${basePath}/`);
 });
 
-test('Rejects non-POST requests to the managed tunnel route instead of rendering the app', async ({ request }) => {
-  test.skip(tunnelRouteMode !== 'static', 'Requires a known managed tunnel path');
-
-  const response = await request.get('/monitor');
-
-  expect(response.status()).toBe(405);
-  expect(response.headers()['allow']).toBe('POST');
-});
-
 function pathnameMatchesTunnelRoute(pathname: string): boolean {
   return typeof expectedTunnelPathMatcher === 'string'
     ? pathname === expectedTunnelPathMatcher
diff --git a/docs/repeated-init.md b/docs/repeated-init.md
index a8f6445f0ffc..f584225a858b 100644
--- a/docs/repeated-init.md
+++ b/docs/repeated-init.md
@@ -37,7 +37,7 @@ When `init()` replaces a client, nothing closes the old one:
 | Entry point                                                               | Repeated call                                                                                                                                                         |
 | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `initAndBind` (browser and its wrappers, Deno), Node `_init`, Vercel Edge | Warns, then replaces the client. Returns the new client.                                                                                                              |
-| Next.js server, Remix server, Hono Node                                   | Keeps the first client and returns it. Logs in debug mode only.                                                                                                       |
+| Next.js server, Remix server, Astro server, Hono Node                     | Keeps the first client and returns it. Logs in debug mode only.                                                                                                       |
 | Hono Bun and Deno                                                         | Keeps the first client and returns it. Warns with its own text.                                                                                                       |
 | Nuxt server                                                               | Keeps the first client and returns it. Logs that a `--import` preload is no longer needed.                                                                            |
 | Cloudflare (default)                                                      | Keeps the first client of the isolate and returns it, unless that client is closed or closing. `cacheClient: false` makes a new client on each call, with no warning. |
diff --git a/packages/astro/src/integration/index.ts b/packages/astro/src/integration/index.ts
index f56e4fa3bd1b..f35e13173481 100644
--- a/packages/astro/src/integration/index.ts
+++ b/packages/astro/src/integration/index.ts
@@ -198,7 +198,9 @@ export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
           // This ensures Sentry.init() runs in dev mode (where the Vite plugin doesn't fire)
           // and also serves as the fallback for non-Cloudflare adapters in production.
           if (serverInitSnippet) {
-            updateConfig({ vite: { plugins: [makeServerInitVitePlugin(serverInitSnippet)] } });
+            updateConfig({
+              vite: { plugins: [makeServerInitVitePlugin(serverInitSnippet, { injectIntoEntry: !isCloudflare })] },
+            });
             injectScript('page-ssr', SERVER_INIT_IMPORT);
           }
 
diff --git a/packages/astro/src/integration/serverInit.ts b/packages/astro/src/integration/serverInit.ts
index 111ad3c06b42..830ba6c20f46 100644
--- a/packages/astro/src/integration/serverInit.ts
+++ b/packages/astro/src/integration/serverInit.ts
@@ -14,12 +14,18 @@ export const SERVER_INIT_IMPORT = `import "${SERVER_INIT_MODULE}";\n`;
 
 /**
  * Serves the server init as one module that SSR pages and the Sentry middleware both import, so it runs once, on
- * whichever request comes first. With only the `page-ssr` script, a request that renders no SSR page, like a tunnel
- * request from a prerendered page on a cold server, would find no client.
+ * whichever request comes first. With `injectIntoEntry`, a build also imports it from the server entry, so the SDK is
+ * set up before the server takes its first request: a tunnel request from a prerendered page on a cold server renders
+ * no SSR page and would otherwise reach the app before the runtime answers tunnel requests.
  */
-export function makeServerInitVitePlugin(serverInitSnippet: string): VitePlugin {
+export function makeServerInitVitePlugin(serverInitSnippet: string, { injectIntoEntry = false } = {}): VitePlugin {
+  let isBuild = false;
+
   return {
     name: 'sentry-astro-server-init',
+    configResolved: config => {
+      isBuild = config.command === 'build';
+    },
     resolveId: id => (id === SERVER_INIT_MODULE || id === SENTRY_MIDDLEWARE_MODULE ? `\0${id}` : null),
     load: id => {
       if (id === `\0${SERVER_INIT_MODULE}`) {
@@ -30,5 +36,13 @@ export function makeServerInitVitePlugin(serverInitSnippet: string): VitePlugin
         ? `${SERVER_INIT_IMPORT}export { onRequest } from "@sentry/astro/middleware";\n`
         : null;
     },
+    transform(code, id, options) {
+      // The dev server's module graph has no server entry, and an import added to what it marks as one hangs it.
+      if (!injectIntoEntry || !isBuild || !options?.ssr || !this.getModuleInfo(id)?.isEntry) {
+        return null;
+      }
+
+      return { code: `${SERVER_INIT_IMPORT}${code}`, map: null };
+    },
   };
 }
diff --git a/packages/astro/src/server/middleware.ts b/packages/astro/src/server/middleware.ts
index 410fe0c9a8be..e6a72f4b9dbe 100644
--- a/packages/astro/src/server/middleware.ts
+++ b/packages/astro/src/server/middleware.ts
@@ -26,10 +26,7 @@ import {
   filterCollectedUrl,
   filterCollectedUrlQuery,
 } from '@sentry/core';
-import {
-  flushIfServerless,
-  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
-} from '@sentry/core/server';
+import { flushIfServerless } from '@sentry/core/server';
 import {
   captureException,
   continueTrace,
@@ -90,11 +87,6 @@ export const handleRequest: (options?: MiddlewareOptions) => MiddlewareHandler =
       return next();
     }
 
-    const tunnelResponse = handleServedTunnelRequest(ctx.request);
-    if (tunnelResponse) {
-      return tunnelResponse;
-    }
-
     const isDynamicPageRequest = checkIsDynamicPageRequest(ctx);
 
     // For static (prerendered) routes, we only want to inject the parametrized route meta tags
diff --git a/packages/astro/src/server/sdk.ts b/packages/astro/src/server/sdk.ts
index 557c1b7812d7..5462ce4a6968 100644
--- a/packages/astro/src/server/sdk.ts
+++ b/packages/astro/src/server/sdk.ts
@@ -1,14 +1,24 @@
 import { SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { HTTP_SERVER } from '@sentry/conventions/op';
-import { applySdkMetadata } from '@sentry/core';
+import { _INTERNAL_getActiveClient, applySdkMetadata, debug } from '@sentry/core';
 import type { NodeClient, NodeOptions } from '@sentry/node';
 import { init as initNodeSdk } from '@sentry/node';
+import { DEBUG_BUILD } from '../debug-build';
 
 /**
  *
  * @param options
  */
 export function init(options: NodeOptions): NodeClient | undefined {
+  // The integration imports the server config from the server entry and from SSR pages, and a `node --import`
+  // preload of it is supported too. The first init wins.
+  const existingClient = _INTERNAL_getActiveClient<NodeClient>();
+  if (existingClient) {
+    DEBUG_BUILD && debug.log('SDK already initialized');
+
+    return existingClient;
+  }
+
   const opts = {
     ...options,
   };
diff --git a/packages/astro/test/server/middleware.test.ts b/packages/astro/test/server/middleware.test.ts
index fd9f0dc2a139..b205af292372 100644
--- a/packages/astro/test/server/middleware.test.ts
+++ b/packages/astro/test/server/middleware.test.ts
@@ -2,7 +2,6 @@ import { HTTP_REQUEST_METHOD, SENTRY_SEGMENT_NAME_SOURCE, URL_FULL, URL_PATH } f
 import type { Client, Span } from '@sentry/core';
 
 import * as SentryCore from '@sentry/core';
-import * as SentryCoreServer from '@sentry/core/server';
 import * as SentryNode from '@sentry/node';
 import type { APIContext } from 'astro';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -34,27 +33,6 @@ const STATIC_REQUEST_CONTEXT = {
   url: new URL('https://myDomain.io/users/'),
 };
 
-describe('sentryMiddleware with the managed tunnel', () => {
-  it('answers tunnel requests without calling the rest of the middleware chain', async () => {
-    const getClientSpy = vi.spyOn(SentryNode, 'getClient').mockReturnValue({} as Client);
-    const tunnelResponse = new Response('forwarded');
-    const matcherSpy = vi
-      .spyOn(SentryCoreServer, '_INTERNAL_handleServedTunnelRequest')
-      .mockReturnValue(Promise.resolve(tunnelResponse));
-    const next = vi.fn();
-    const request = new Request('https://myDomain.io/abc123', { method: 'POST' });
-
-    const response = await handleRequest()({ ...DYNAMIC_REQUEST_CONTEXT, request } as unknown as APIContext, next);
-
-    expect(response).toBe(tunnelResponse);
-    expect(matcherSpy).toHaveBeenCalledWith(request);
-    expect(next).not.toHaveBeenCalled();
-
-    getClientSpy.mockRestore();
-    matcherSpy.mockRestore();
-  });
-});
-
 describe('sentryMiddleware', () => {
   const startSpanSpy = vi.spyOn(SentryNode, 'startSpan');
 
diff --git a/packages/nitro/src/runtime/plugins/server.ts b/packages/nitro/src/runtime/plugins/server.ts
index 0aed3618435b..bd0952669626 100644
--- a/packages/nitro/src/runtime/plugins/server.ts
+++ b/packages/nitro/src/runtime/plugins/server.ts
@@ -1,7 +1,4 @@
-import {
-  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
-  _INTERNAL_setTunnelDefaults as setTunnelDefaults,
-} from '@sentry/core/server';
+import { _INTERNAL_setTunnelDefaults as setTunnelDefaults } from '@sentry/core/server';
 import { definePlugin } from 'nitro';
 import { useRuntimeConfig } from 'nitro/runtime-config';
 import { captureErrorHook } from '../hooks/captureErrorHook';
@@ -9,13 +6,8 @@ import { captureErrorHook } from '../hooks/captureErrorHook';
 export default definePlugin(nitroApp => {
   nitroApp.hooks.hook('error', captureErrorHook);
 
-  // Nitro runs the app's `middleware/` before anything a module registers, so an auth middleware there would block
-  // the tunnel. Every preset hands requests to `nitroApp.fetch` after the plugins ran, so wrapping it goes first,
-  // before route rules and middleware. Requests still carry Nitro's `baseURL` here, so the tunnel is served under it,
-  // unless a framework serves the app under another prefix: `@sentry/solidstart` sets `sentryTunnelBasePath` to Vite's
-  // `base`.
+  // The runtime answers managed tunnel requests, under Nitro's `baseURL` unless a framework serves the app under
+  // another prefix: `@sentry/solidstart` sets `sentryTunnelBasePath` to Vite's `base`.
   const runtimeConfig = useRuntimeConfig() as { app?: { baseURL?: string }; sentryTunnelBasePath?: string };
   setTunnelDefaults({ basePath: runtimeConfig.sentryTunnelBasePath || runtimeConfig.app?.baseURL });
-  const appFetch = nitroApp.fetch;
-  nitroApp.fetch = request => handleServedTunnelRequest(request) ?? appFetch(request);
 });
diff --git a/packages/nuxt/src/runtime/plugins/tunnel-legacy.server.ts b/packages/nuxt/src/runtime/plugins/tunnel-legacy.server.ts
index da950ea3ea4f..51aed67bffed 100644
--- a/packages/nuxt/src/runtime/plugins/tunnel-legacy.server.ts
+++ b/packages/nuxt/src/runtime/plugins/tunnel-legacy.server.ts
@@ -1,33 +1,12 @@
-import {
-  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
-  _INTERNAL_isServedTunnelRequest as isServedTunnelRequest,
-  _INTERNAL_setTunnelDefaults as setTunnelDefaults,
-} from '@sentry/core/server';
-import { eventHandler, toWebRequest } from 'h3';
+import { _INTERNAL_setTunnelDefaults as setTunnelDefaults } from '@sentry/core/server';
 import type { NitroAppPlugin } from 'nitropack';
 import { useRuntimeConfig } from 'nitropack/runtime';
 
 /**
- * Answers managed tunnel requests on Nuxt v3 and v4 (Nitro v2), from the first layer of the h3 app. That runs
- * before route rules and the app's `server/middleware`.
+ * Serves the managed tunnel under Nuxt's `app.baseURL` on Nuxt v3 and v4 (Nitro v2). The runtime answers the
+ * requests.
  */
-export default (nitroApp => {
-  // The first layer sees the path before Nitro strips `app.baseURL`, so the tunnel is served under it.
+export default (() => {
   // `useRuntimeConfig` also picks up a `NUXT_APP_BASE_URL` set at runtime, the same value the browser gets.
   setTunnelDefaults({ basePath: useRuntimeConfig().app?.baseURL });
-
-  // Not the `request` hook: h3 still runs the first layer after a hook answered, and with a `headers` route rule
-  // that layer throws for writing headers on the sent response.
-  nitroApp.h3App.stack.unshift({
-    route: '',
-    handler: eventHandler(event => {
-      // Checked on the method and path first, so no other request's body gets wrapped in a web `Request`.
-      if (!isServedTunnelRequest({ method: event.method, url: event.path })) {
-        return undefined;
-      }
-
-      // A returned `Response` is sent and ends the request, while `undefined` hands it to the next layer.
-      return handleServedTunnelRequest(toWebRequest(event));
-    }),
-  });
 }) satisfies NitroAppPlugin;
diff --git a/packages/nuxt/src/runtime/plugins/tunnel.server.ts b/packages/nuxt/src/runtime/plugins/tunnel.server.ts
index 9a63b6fc7d68..611466e662df 100644
--- a/packages/nuxt/src/runtime/plugins/tunnel.server.ts
+++ b/packages/nuxt/src/runtime/plugins/tunnel.server.ts
@@ -1,20 +1,11 @@
-import {
-  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
-  _INTERNAL_setTunnelDefaults as setTunnelDefaults,
-} from '@sentry/core/server';
+import { _INTERNAL_setTunnelDefaults as setTunnelDefaults } from '@sentry/core/server';
 import { useRuntimeConfig } from 'nitro/runtime-config';
-import type { NitroAppPlugin, NitroApp } from 'nitro/types';
+import type { NitroAppPlugin } from 'nitro/types';
 
 /**
- * Answers managed tunnel requests on Nuxt v5+ (Nitro v3+).
+ * Serves the managed tunnel under Nuxt's `app.baseURL` on Nuxt v5+ (Nitro v3+). The runtime answers the requests.
  */
-export default ((nitroApp: NitroApp) => {
-  // Nitro runs the app's `server/middleware` before anything a module registers, so an auth middleware there would
-  // block the tunnel. Every preset hands requests to `nitroApp.fetch` after the plugins ran, so wrapping it goes
-  // first, before route rules and middleware.
-  // Requests still carry Nuxt's `app.baseURL` here, so the tunnel is served under it. `useRuntimeConfig` also picks
-  // up a `NUXT_APP_BASE_URL` set at runtime.
+export default (() => {
+  // `useRuntimeConfig` also picks up a `NUXT_APP_BASE_URL` set at runtime, the same value the browser gets.
   setTunnelDefaults({ basePath: (useRuntimeConfig() as { app?: { baseURL?: string } }).app?.baseURL });
-  const appFetch = nitroApp.fetch;
-  nitroApp.fetch = request => handleServedTunnelRequest(request) ?? appFetch(request);
 }) satisfies NitroAppPlugin;
diff --git a/packages/nuxt/src/vite/nitroServer.ts b/packages/nuxt/src/vite/nitroServer.ts
index 0a7f358f1182..7401a6c1596d 100644
--- a/packages/nuxt/src/vite/nitroServer.ts
+++ b/packages/nuxt/src/vite/nitroServer.ts
@@ -120,7 +120,7 @@ function setupDeprecatedInjectMode(
 }
 
 /**
- * Adds the plugin that answers the managed tunnel. The Cloudflare setup has no server config file, so it skips
+ * Adds the plugin that sets the managed tunnel's base path. The Cloudflare setup has no server config file, so it skips
  * `setupNitroServer` and adds this on its own.
  */
 export function addTunnelPlugin(serverApi: ServerApi): void {
diff --git a/packages/react-router/src/server/tunnelRoute.ts b/packages/react-router/src/server/tunnelRoute.ts
index 7b8541f40d2a..7b6d257f5c31 100644
--- a/packages/react-router/src/server/tunnelRoute.ts
+++ b/packages/react-router/src/server/tunnelRoute.ts
@@ -1,70 +1,15 @@
-import { debug, getClient } from '@sentry/core';
-import {
-  _INTERNAL_getTunnelPaths as getTunnelPaths,
-  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
-  _INTERNAL_setTunnelDefaults as setTunnelDefaults,
-} from '@sentry/core/server';
-import { DEBUG_BUILD } from '../common/debug-build';
-
-// Never matches a request, for when the managed tunnel is off.
-const DISABLED_TUNNEL_PATH = '/__sentry-tunnel-disabled__';
+import { _INTERNAL_setTunnelDefaults as setTunnelDefaults } from '@sentry/core/server';
 
 /**
- * The resource routes that serve the managed tunnel, one per tunnel path. `sentryReactRouter()` adds them to the
- * server build, since React Router has no request hook to answer from and a route matches only one path. Not meant
- * to be used directly.
+ * Serves the managed tunnel under the app's `basename`, which React Router leaves in the request URL. The runtime
+ * answers the requests, so it adds no routes. `sentryReactRouter()` calls it from the server build. Not meant to be
+ * used directly.
  *
- * @param basename The app's `basename`, which React Router matches the routes under but leaves in the request URL.
+ * @param basename The app's `basename`.
  */
 export function createSentryTunnelRoutes(basename?: string): Record<string, Record<string, unknown>> {
   // Runs when the server build loads. Clients created later, e.g. per request on Cloudflare, start with the basename.
   setTunnelDefaults({ basePath: basename });
 
-  // `init` runs from `--import` before the server build loads, so the client and its tunnel paths are usually known.
-  if (!getClient()) {
-    return { 'sentry-tunnel': makeTunnelRoute('sentry-tunnel', getLazyTunnelPath) };
-  }
-
-  return Object.fromEntries(
-    getTunnelPaths().map((path, index) => {
-      const id = `sentry-tunnel-${index}`;
-
-      return [id, makeTunnelRoute(id, () => path)];
-    }),
-  );
-}
-
-/**
- * The path of the single route added when `init` runs after the server build loads, e.g. per request on Cloudflare.
- * React Router reads it on its first request and keeps it until the server restarts.
- */
-function getLazyTunnelPath(): string {
-  if (!getClient()) {
-    DEBUG_BUILD && debug.warn('The managed tunnel stays off until restart: a request came in before `Sentry.init`.');
-    return DISABLED_TUNNEL_PATH;
-  }
-
-  const [path, ...otherPaths] = getTunnelPaths();
-  if (otherPaths.length) {
-    DEBUG_BUILD && debug.warn(`Sentry.init ran after the server build loaded, so only ${path} is served.`);
-  }
-
-  return path ?? DISABLED_TUNNEL_PATH;
-}
-
-function makeTunnelRoute(id: string, getPath: () => string): Record<string, unknown> {
-  return {
-    id,
-    parentId: undefined,
-    index: undefined,
-    caseSensitive: undefined,
-    get path(): string {
-      return getPath();
-    },
-    module: {
-      action: ({ request }: { request: Request }) =>
-        handleServedTunnelRequest(request) ?? new Response(null, { status: 404 }),
-      loader: () => new Response(null, { status: 405, headers: { Allow: 'POST' } }),
-    },
-  };
+  return {};
 }
diff --git a/packages/react-router/src/vite/makeTunnelRoutePlugin.ts b/packages/react-router/src/vite/makeTunnelRoutePlugin.ts
index 5d2c12cb244c..b3cda4d94507 100644
--- a/packages/react-router/src/vite/makeTunnelRoutePlugin.ts
+++ b/packages/react-router/src/vite/makeTunnelRoutePlugin.ts
@@ -3,8 +3,8 @@ import type { Plugin } from 'vite';
 const SERVER_BUILD_MODULE_ID = 'virtual:react-router/server-build';
 
 /**
- * Adds the managed tunnel routes to the server build. They only serve requests when `serveTunnelIntegration` is set
- * up. The server build exports the app's `basename`, which the route needs to match the request URL.
+ * Passes the app's `basename` from the server build to the managed tunnel, which serves under it. Only applies when
+ * `serveTunnelIntegration` is set up.
  */
 export function makeTunnelRoutePlugin(): Plugin {
   return {
diff --git a/packages/react-router/test/server/tunnelRoute.test.ts b/packages/react-router/test/server/tunnelRoute.test.ts
deleted file mode 100644
index 23c5739458a5..000000000000
--- a/packages/react-router/test/server/tunnelRoute.test.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import type { Client } from '@sentry/core';
-import { createEnvelope, getCurrentScope, getTunnelPath, makeDsn, serializeEnvelope } from '@sentry/core';
-import { _INTERNAL_resetTunnelDefaults, serveTunnelIntegration } from '@sentry/core/server';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { createSentryTunnelRoutes } from '../../src/server/tunnelRoute';
-
-const DSN = 'https://public@o1.ingest.sentry.io/1337';
-
-type TunnelRoute = {
-  path: string;
-  parentId: undefined;
-  module: { action: (args: { request: Request }) => Promise<Response> | Response; loader: () => Response };
-};
-
-function firstRoute(basename?: string): TunnelRoute {
-  return Object.values(createSentryTunnelRoutes(basename))[0] as TunnelRoute;
-}
-
-/** Sets a client, with `serveTunnelIntegration` set up when `managedTunnel` is given. */
-function setClient(managedTunnel: object | undefined): void {
-  const options = { dsn: DSN };
-  const client = { getDsn: () => makeDsn(DSN), getOptions: () => options } as unknown as Client;
-  getCurrentScope().setClient(client);
-  if (managedTunnel) {
-    serveTunnelIntegration(managedTunnel).setup!(client);
-  }
-}
-
-const ENVELOPE = serializeEnvelope(createEnvelope({ dsn: DSN }, [])) as string;
-
-describe('createSentryTunnelRoutes', () => {
-  afterEach(() => {
-    getCurrentScope().setClient(undefined);
-    _INTERNAL_resetTunnelDefaults();
-    vi.unstubAllGlobals();
-  });
-
-  it('is a top-level route at the tunnel path when `serveTunnelIntegration` is set up', () => {
-    setClient({});
-    const route = firstRoute();
-
-    expect(route.parentId).toBeUndefined();
-    expect(route.path).toBe(getTunnelPath(DSN));
-  });
-
-  it('adds no route when the tunnel is off, and a path that never matches when Sentry is not initialized yet', () => {
-    const route = firstRoute();
-    const pathWithoutClient = route.path;
-    setClient(undefined);
-
-    expect(pathWithoutClient).toBe('/__sentry-tunnel-disabled__');
-    expect(route.path).toBe('/__sentry-tunnel-disabled__');
-    expect(createSentryTunnelRoutes()).toEqual({});
-  });
-
-  it('forwards tunnel POSTs and rejects other methods', async () => {
-    setClient({});
-    vi.stubGlobal(
-      'fetch',
-      vi.fn(() => Promise.resolve(new Response('forwarded'))),
-    );
-    const route = firstRoute();
-    const request = new Request(`http://localhost${getTunnelPath(DSN)}`, {
-      method: 'POST',
-      body: ENVELOPE,
-      headers: { 'content-length': String(ENVELOPE.length) },
-    });
-
-    expect(await (await route.module.action({ request })).text()).toBe('forwarded');
-    expect(route.module.loader().status).toBe(405);
-  });
-
-  it('serves the tunnel under `basename`, which React Router leaves in the request URL', async () => {
-    setClient({});
-    vi.stubGlobal(
-      'fetch',
-      vi.fn(() => Promise.resolve(new Response('forwarded'))),
-    );
-    const route = firstRoute('/app/');
-    const request = new Request(`http://localhost/app${getTunnelPath(DSN)}`, {
-      method: 'POST',
-      body: ENVELOPE,
-      headers: { 'content-length': String(ENVELOPE.length) },
-    });
-
-    // React Router matches the route under `basename` itself, so the path stays relative to it.
-    expect(route.path).toBe(getTunnelPath(DSN));
-    expect(await (await route.module.action({ request })).text()).toBe('forwarded');
-  });
-});
diff --git a/packages/remix/src/v3/server/instrument.ts b/packages/remix/src/v3/server/instrument.ts
index f63578e2f0f9..0094d56e7594 100644
--- a/packages/remix/src/v3/server/instrument.ts
+++ b/packages/remix/src/v3/server/instrument.ts
@@ -1,7 +1,6 @@
 import * as diagnosticsChannel from 'node:diagnostics_channel';
 import { createMultiMatcher } from 'remix/route-pattern/match';
 import { consoleSandbox } from '@sentry/core';
-import { _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest } from '@sentry/core/server';
 import type { OrchestrionChannelContext } from '@sentry/server-utils';
 import { remixV3Channels } from '@sentry/server-utils/orchestrion/config';
 
@@ -59,7 +58,7 @@ function subscribeToCreateRouter(): void {
 }
 
 /**
- * Report errors from any fetch handler, router or not, and answer managed tunnel requests before it runs.
+ * Report errors from any fetch handler, router or not.
  * The middleware only sees failures inside a router; this is the only hook that covers a plain handler.
  * No abort guard is needed, because the listener drops aborted requests before calling `onError`.
  */
@@ -72,7 +71,6 @@ function subscribeToCreateRequestListener(): void {
       start(data) {
         try {
           injectOnError(ensureOptions(data.arguments, 1));
-          wrapFetchHandler(data.arguments);
         } catch {
           // Ignored on purpose.
         }
@@ -84,21 +82,6 @@ function subscribeToCreateRequestListener(): void {
     });
 }
 
-/**
- * Answers managed tunnel requests before the app's fetch handler, so code the app runs in front of its router never
- * sees them. The router middleware still answers them for apps served some other way.
- */
-function wrapFetchHandler(args: unknown[]): void {
-  const handler = args[0];
-  if (typeof handler !== 'function') {
-    return;
-  }
-
-  args[0] = function sentryFetchHandler(this: unknown, request: Request, ...rest: unknown[]): unknown {
-    return handleServedTunnelRequest(request) ?? handler.call(this, request, ...rest);
-  };
-}
-
 function injectOnError(raw: Record<string, unknown> | undefined): void {
   if (!raw || markInjected(raw)) {
     return;
diff --git a/packages/remix/src/v3/server/middleware.ts b/packages/remix/src/v3/server/middleware.ts
index 4ca54f648383..f2ce59c48f01 100644
--- a/packages/remix/src/v3/server/middleware.ts
+++ b/packages/remix/src/v3/server/middleware.ts
@@ -10,7 +10,6 @@ import {
   updateSpanName,
   winterCGRequestToRequestData,
 } from '@sentry/core';
-import { _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest } from '@sentry/core/server';
 
 import { formatRouteTiming } from '../routeTiming';
 import type { MatcherLike, MiddlewareLike, NextFunctionLike, RequestContextLike } from '../types';
@@ -26,11 +25,6 @@ import { resolveRoutePattern } from './route';
  */
 export function sentryRemixMiddleware(matcher: MatcherLike): MiddlewareLike {
   return async function sentryMiddleware(context: RequestContextLike, next: NextFunctionLike): Promise<Response> {
-    const tunnelResponse = handleServedTunnelRequest(context.request);
-    if (tunnelResponse) {
-      return tunnelResponse;
-    }
-
     const isolationScope = getIsolationScope();
     isolationScope.setSDKProcessingMetadata({ normalizedRequest: winterCGRequestToRequestData(context.request) });
 
diff --git a/packages/remix/test/v3/instrument.test.ts b/packages/remix/test/v3/instrument.test.ts
index 85133e8b3ecd..cf22efc91609 100644
--- a/packages/remix/test/v3/instrument.test.ts
+++ b/packages/remix/test/v3/instrument.test.ts
@@ -144,33 +144,3 @@ describe('the createRequestListener error hook', () => {
     expect(args[1]).toEqual(expect.objectContaining({ onError: expect.any(Function) }));
   });
 });
-
-describe('the createRequestListener tunnel', () => {
-  beforeAll(() => {
-    instrumentRemixV3();
-  });
-
-  it("answers a managed tunnel request without calling the app's handler", async () => {
-    const appHandler = vi.fn(() => new Response('app'));
-    const args: unknown[] = [appHandler];
-
-    publishCreateRequestListener(args);
-
-    expect(await (args[0] as (request: Request) => unknown)(new Request(TUNNEL_URL, { method: 'POST' }))).toBe(
-      tunnelResponse,
-    );
-    expect(appHandler).not.toHaveBeenCalled();
-  });
-
-  it("hands every other request to the app's handler", () => {
-    const appResponse = new Response('app');
-    const appHandler = vi.fn(() => appResponse);
-    const args: unknown[] = [appHandler];
-    const request = new Request('http://localhost/page');
-
-    publishCreateRequestListener(args);
-
-    expect((args[0] as (request: Request, client: unknown) => unknown)(request, 'client')).toBe(appResponse);
-    expect(appHandler).toHaveBeenCalledWith(request, 'client');
-  });
-});
diff --git a/packages/remix/test/v3/middleware.test.ts b/packages/remix/test/v3/middleware.test.ts
index e0f1866e78fd..8a8e1e5db21b 100644
--- a/packages/remix/test/v3/middleware.test.ts
+++ b/packages/remix/test/v3/middleware.test.ts
@@ -40,19 +40,6 @@ describe('sentryRemixMiddleware', () => {
     handleServedTunnelRequest.mockReturnValue(undefined);
   });
 
-  it('answers tunnel requests before route matching and the rest of the chain', async () => {
-    const tunnelResponse = new Response('forwarded');
-    handleServedTunnelRequest.mockReturnValue(Promise.resolve(tunnelResponse));
-    const next = vi.fn();
-    const context = contextFor('http://x/abc123');
-
-    const response = await sentryRemixMiddleware(matcherFor('/'))(context, next);
-
-    expect(response).toBe(tunnelResponse);
-    expect(handleServedTunnelRequest).toHaveBeenCalledWith(context.request);
-    expect(next).not.toHaveBeenCalled();
-  });
-
   it('propagates the trace to HTML responses through Server-Timing, ahead of the route', async () => {
     getTraceData.mockReturnValue({ 'sentry-trace': 'abc-def-1', baggage: 'sentry-trace_id=abc' });
     const middleware = sentryRemixMiddleware(matcherFor('/users/:id'));
diff --git a/packages/solidstart/src/nitro/tunnelPlugin.ts b/packages/solidstart/src/nitro/tunnelPlugin.ts
index d423c8839fe0..857dfa8f66af 100644
--- a/packages/solidstart/src/nitro/tunnelPlugin.ts
+++ b/packages/solidstart/src/nitro/tunnelPlugin.ts
@@ -1,37 +1,15 @@
 import { GLOBAL_OBJ } from '@sentry/core';
-import {
-  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
-  _INTERNAL_isServedTunnelRequest as isServedTunnelRequest,
-  _INTERNAL_setTunnelDefaults as setTunnelDefaults,
-} from '@sentry/core/server';
-import { eventHandler, toWebRequest } from 'h3';
+import { _INTERNAL_setTunnelDefaults as setTunnelDefaults } from '@sentry/core/server';
 import type { NitroAppPlugin } from 'nitropack';
 import { TUNNEL_BASE_PATH_GLOBAL } from '../common/tunnel';
 
 /**
- * Answers managed tunnel requests on SolidStart v1 (Nitro v2), from the first layer of the h3 app. That runs before
- * route rules, the app's middleware and routing. `withSentry` registers it.
+ * Serves the managed tunnel under the app's base path on SolidStart v1 (Nitro v2). The runtime answers the requests.
+ * `withSentry` registers it.
  */
-export default (nitroApp => {
-  // The first layer sees the path before Nitro strips `server.baseURL`, so the tunnel is served under it. The server
-  // bundle's banner sets the global before this plugin runs.
+export default (() => {
+  // The server bundle's banner sets the global before this plugin runs.
   setTunnelDefaults({
     basePath: (GLOBAL_OBJ as { [TUNNEL_BASE_PATH_GLOBAL]?: string })[TUNNEL_BASE_PATH_GLOBAL],
   });
-
-  // Not the `request` hook: h3 still runs the first layer after a hook answered, so route rules would act on the
-  // sent response.
-  nitroApp.h3App.stack.unshift({
-    route: '',
-    handler: eventHandler(event => {
-      // Checked on the method and path first, so no other request's body gets wrapped in a web `Request`.
-      if (!isServedTunnelRequest({ method: event.method, url: event.path })) {
-        return undefined;
-      }
-
-      // `toWebRequest` also reads the body of the mock requests serverless presets pass through `localFetch`, which
-      // aren't Node streams. A returned `Response` is sent and ends the request, `undefined` hands it on.
-      return handleServedTunnelRequest(toWebRequest(event));
-    }),
-  });
 }) satisfies NitroAppPlugin;
diff --git a/packages/solidstart/test/nitro/tunnelPlugin.test.ts b/packages/solidstart/test/nitro/tunnelPlugin.test.ts
deleted file mode 100644
index 4baea8a5a12f..000000000000
--- a/packages/solidstart/test/nitro/tunnelPlugin.test.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import type { Client } from '@sentry/core';
-import { createEnvelope, getCurrentScope, getTunnelPath, makeDsn, serializeEnvelope } from '@sentry/core';
-import { _INTERNAL_resetTunnelDefaults, serveTunnelIntegration } from '@sentry/core/server';
-import { createApp, eventHandler, setHeaders, toNodeListener } from 'h3';
-import { fetchNodeRequestHandler } from 'node-mock-http';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import tunnelPlugin from '../../src/nitro/tunnelPlugin';
-
-const DSN = 'https://public@o1.ingest.sentry.io/1337';
-
-type RequestHook = (event: unknown) => Promise<void>;
-
-/**
- * Calls an h3 app wired like Nitro v2's: the `request` hook runs in `onRequest`, and the route rules layer, here
- * with a `headers` rule, comes before the app. Requests come in the way serverless presets pass them through
- * `localFetch`, with node-mock-http's request, which isn't a Node stream.
- */
-function fetchApp(url: string, init: RequestInit): Promise<Response> {
-  const requestHooks: RequestHook[] = [];
-  const app = createApp({
-    onRequest: async event => {
-      for (const hook of requestHooks) {
-        await hook(event);
-      }
-    },
-    onError: error => onError(error),
-  });
-  app.use(eventHandler(event => setHeaders(event, { 'x-route-rule': '1' })));
-  app.use(eventHandler(() => 'app'));
-  (tunnelPlugin as (nitroApp: unknown) => void)({
-    h3App: app,
-    hooks: { hook: (name: string, fn: RequestHook) => name === 'request' && requestHooks.push(fn) },
-  });
-
-  return fetchNodeRequestHandler(toNodeListener(app), `http://localhost${url}`, init);
-}
-
-const onError = vi.fn();
-
-describe('SolidStart v1 tunnel plugin', () => {
-  afterEach(() => {
-    getCurrentScope().setClient(undefined);
-    _INTERNAL_resetTunnelDefaults();
-    vi.unstubAllGlobals();
-    vi.clearAllMocks();
-  });
-
-  it('answers tunnel requests before route rules and the app with `serveTunnelIntegration`', async () => {
-    const options = { dsn: DSN };
-    const client = { getDsn: () => makeDsn(DSN), getOptions: () => options } as unknown as Client;
-    getCurrentScope().setClient(client);
-    serveTunnelIntegration().setup!(client);
-    const sentryFetch = vi.fn((_url: string, _init: RequestInit) => Promise.resolve(new Response('forwarded')));
-    vi.stubGlobal('fetch', sentryFetch);
-    const envelope = serializeEnvelope(createEnvelope({ dsn: DSN }, [])) as string;
-
-    const response = await fetchApp(getTunnelPath(DSN)!, {
-      method: 'POST',
-      body: envelope,
-      headers: { 'content-length': String(envelope.length) },
-    });
-
-    expect(await response.text()).toBe('forwarded');
-    expect(await new Response(sentryFetch.mock.lastCall![1].body).text()).toBe(envelope);
-    // A route rule that ran after the answer would fail to set headers on the sent response.
-    expect(response.headers.get('x-route-rule')).toBeNull();
-    expect(onError).not.toHaveBeenCalled();
-  });
-
-  it('serves no tunnel without `serveTunnelIntegration`', async () => {
-    const options = { dsn: DSN };
-    getCurrentScope().setClient({ getDsn: () => makeDsn(DSN), getOptions: () => options } as unknown as Client);
-    const envelope = serializeEnvelope(createEnvelope({ dsn: DSN }, [])) as string;
-
-    const response = await fetchApp(getTunnelPath(DSN)!, {
-      method: 'POST',
-      body: envelope,
-      headers: { 'content-length': String(envelope.length) },
-    });
-
-    expect(await response.text()).toBe('app');
-  });
-
-  it('leaves every other request to the app', async () => {
-    const response = await fetchApp('/api/users', { method: 'POST', body: 'x' });
-
-    expect(await response.text()).toBe('app');
-    expect(response.headers.get('x-route-rule')).toBe('1');
-  });
-});
diff --git a/packages/sveltekit/src/server-common/handle.ts b/packages/sveltekit/src/server-common/handle.ts
index 08bcdb79fa70..8e81c19ef28e 100644
--- a/packages/sveltekit/src/server-common/handle.ts
+++ b/packages/sveltekit/src/server-common/handle.ts
@@ -19,11 +19,7 @@ import {
   withIsolationScope,
   filterCollectedUrl,
 } from '@sentry/core';
-import {
-  flushIfServerless,
-  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
-  _INTERNAL_setTunnelDefaults as setTunnelDefaults,
-} from '@sentry/core/server';
+import { flushIfServerless, _INTERNAL_setTunnelDefaults as setTunnelDefaults } from '@sentry/core/server';
 import { getTunnelBasePath } from '../common/tunnel';
 import type { Handle, ResolveOptions } from '@sveltejs/kit';
 import { DEBUG_BUILD } from '../common/debug-build';
@@ -301,11 +297,6 @@ export function sentryHandle(handlerOptions?: SentryHandleOptions): Handle {
   };
 
   const sentryRequestHandler: Handle = input => {
-    const tunnelResponse = handleServedTunnelRequest(input.event.request);
-    if (tunnelResponse) {
-      return tunnelResponse;
-    }
-
     const backwardsForwardsCompatibleEvent = input.event as typeof input.event & BackwardsForwardsCompatibleEvent;
 
     // Escape hatch to suppress request isolation and trace continuation (see initCloudflareSentryHandle)
diff --git a/packages/sveltekit/test/server-common/handle.test.ts b/packages/sveltekit/test/server-common/handle.test.ts
index 49128a9d47b1..5da1cd5f211e 100644
--- a/packages/sveltekit/test/server-common/handle.test.ts
+++ b/packages/sveltekit/test/server-common/handle.test.ts
@@ -4,7 +4,6 @@ import { getCapturedScopesOnSpan, getRootSpan, getSpanDescendants, spanIsSampled
 import * as SentryCore from '@sentry/core';
 import { NodeClient, serveTunnelIntegration, setCurrentClient } from '@sentry/node';
 import { _INTERNAL_resetTunnelDefaults } from '@sentry/core/server';
-import { TUNNEL_BASE_PATH_GLOBAL } from '../../src/common/tunnel';
 import type { Handle } from '@sveltejs/kit';
 import { redirect } from '@sveltejs/kit';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -146,16 +145,6 @@ describe('sentryHandle with span streaming', () => {
 describe('sentryHandle with the managed tunnel', () => {
   const DSN = 'https://public@o1.ingest.sentry.io/1337';
 
-  function makeTunnelRequest(path: string): Request {
-    const body = SentryCore.serializeEnvelope(SentryCore.createEnvelope({ dsn: DSN }, [])) as string;
-
-    return new Request(`http://localhost:3000${path}`, {
-      method: 'POST',
-      body,
-      headers: { 'content-length': String(body.length) },
-    });
-  }
-
   beforeEach(() => {
     vi.stubGlobal(
       'fetch',
@@ -171,36 +160,6 @@ describe('sentryHandle with the managed tunnel', () => {
     _INTERNAL_resetTunnelDefaults();
   });
 
-  it('answers tunnel requests without resolving the route', async () => {
-    const mockResolve = vi.fn();
-
-    const response = await sentryHandle()({
-      event: mockEvent({ request: makeTunnelRequest(SentryCore.getTunnelPath(DSN)!), route: { id: null } }),
-      resolve: mockResolve,
-    });
-
-    expect(await response.text()).toBe('forwarded');
-    expect(mockResolve).not.toHaveBeenCalled();
-  });
-
-  it('serves the tunnel under the base path `sentrySvelteKit()` set before the handle was created', async () => {
-    vi.stubGlobal(TUNNEL_BASE_PATH_GLOBAL, '/app');
-    const mockResolve = vi.fn(() => Promise.resolve(new Response('app')));
-    const handle = sentryHandle();
-
-    const underBasePath = await handle({
-      event: mockEvent({ request: makeTunnelRequest(`/app${SentryCore.getTunnelPath(DSN)!}`), route: { id: null } }),
-      resolve: mockResolve,
-    });
-    const atRoot = await handle({
-      event: mockEvent({ request: makeTunnelRequest(SentryCore.getTunnelPath(DSN)!), route: { id: null } }),
-      resolve: mockResolve,
-    });
-
-    expect(await underBasePath.text()).toBe('forwarded');
-    expect(await atRoot.text()).toBe('app');
-  });
-
   it('resolves every other request', async () => {
     const mockResolve = vi.fn(() => Promise.resolve(new Response('app')));
 
diff --git a/packages/tanstackstart-react/src/server/tunnelRoute.ts b/packages/tanstackstart-react/src/server/tunnelRoute.ts
index cd0c4a0e1389..efba3e1722ab 100644
--- a/packages/tanstackstart-react/src/server/tunnelRoute.ts
+++ b/packages/tanstackstart-react/src/server/tunnelRoute.ts
@@ -3,8 +3,6 @@ import type { ServerTunnelOptions } from '@sentry/core';
 import { dsnToString, escapeStringForRegex, getClient, handleTunnelRequest } from '@sentry/core';
 import {
   _INTERNAL_forwardTunnelRequest as forwardTunnelRequest,
-  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
-  _INTERNAL_isServedTunnelRequest as isServedTunnelRequest,
   _INTERNAL_setTunnelDefaults as setTunnelDefaults,
 } from '@sentry/core/server';
 import type { ServerEntry } from './wrapFetchWithSentry';
@@ -99,8 +97,9 @@ export function createSentryTunnelRoute(options: CreateSentryTunnelRouteOptions)
 }
 
 /**
- * Answers managed tunnel requests before the server entry runs. The `sentryTanstackStart` Vite plugin applies this
- * to the app's server entry automatically, with its `tunnelRoute` and the base path Start routes on.
+ * Enables the managed tunnel for the server entry, which the runtime then answers. The `sentryTanstackStart` Vite
+ * plugin applies this to the app's server entry automatically, with its `tunnelRoute` and the base path Start routes
+ * on.
  *
  * `tunnelRoute` enables the managed tunnel on every server client the same way `serveTunnelIntegration` does, unless
  * that integration is set up too, and the tunnel is then served from the client's config like in every other SDK.
@@ -112,33 +111,9 @@ export function wrapServerEntryWithSentryTunnel<T extends ServerEntry>(
   tunnelRoute?: ServerTunnelOptions,
   basePath?: string,
 ): T {
-  // Runs when the server entry loads, before any request. Requests still carry Start's base path here, so the tunnel
-  // is served under it.
+  // Runs when the server entry loads, before any request. Requests still carry Start's base path, so the tunnel is
+  // served under it.
   setTunnelDefaults({ tunnel: tunnelRoute, forward: forwardTunnelRequest, basePath });
 
-  // A class entry, like Cloudflare's `WorkerEntrypoint`, can't be spread into an object. The tunnel is then served
-  // by the wrapped default server entry it calls.
-  if (typeof entry === 'function') {
-    return entry;
-  }
-
-  // Keeps the prototype, so a class instance entry keeps its other handlers, like `scheduled` or `queue`. `fetch` is
-  // defined rather than assigned, which a read-only `fetch` on a frozen prototype would reject.
-  return Object.create(Object.getPrototypeOf(entry), {
-    ...Object.getOwnPropertyDescriptors(entry),
-    fetch: {
-      // Cloudflare Workers pass `env` and `ctx` after the request, and `withSentry` needs `ctx` to flush.
-      value: (request: Request, ...rest: unknown[]) => {
-        // Start would render the app for any other method on a tunnel path, running its root loaders.
-        if (request.method !== 'POST' && isServedTunnelRequest({ method: 'POST', url: request.url })) {
-          return new Response(null, { status: 405, headers: { Allow: 'POST' } });
-        }
-
-        return handleServedTunnelRequest(request) ?? entry.fetch(request, ...rest);
-      },
-      writable: true,
-      configurable: true,
-      enumerable: true,
-    },
-  }) as T;
+  return entry;
 }
diff --git a/packages/tanstackstart-react/test/server/wrapServerEntryWithSentryTunnel.test.ts b/packages/tanstackstart-react/test/server/wrapServerEntryWithSentryTunnel.test.ts
index 7d3fa6d030d3..d373d8fc84be 100644
--- a/packages/tanstackstart-react/test/server/wrapServerEntryWithSentryTunnel.test.ts
+++ b/packages/tanstackstart-react/test/server/wrapServerEntryWithSentryTunnel.test.ts
@@ -38,15 +38,6 @@ describe('wrapServerEntryWithSentryTunnel', () => {
     vi.clearAllMocks();
   });
 
-  it('answers the tunnel path when `serveTunnelIntegration` is set up, without calling the app', async () => {
-    setClient({});
-
-    const response = await wrapServerEntryWithSentryTunnel({ fetch: appFetch }).fetch(makeEnvelopeRequest(TUNNEL_URL));
-
-    expect(await response.text()).toBe('forwarded');
-    expect(appFetch).not.toHaveBeenCalled();
-  });
-
   it('hands every request to the app when the managed tunnel is off', async () => {
     setClient(undefined);
 
@@ -56,40 +47,6 @@ describe('wrapServerEntryWithSentryTunnel', () => {
     expect(sentryFetch).not.toHaveBeenCalled();
   });
 
-  it('serves the tunnel with build-time options even without `serveTunnelIntegration`', async () => {
-    setClient(undefined);
-
-    const response = await wrapServerEntryWithSentryTunnel({ fetch: appFetch }, {}).fetch(
-      makeEnvelopeRequest(TUNNEL_URL),
-    );
-
-    expect(await response.text()).toBe('forwarded');
-  });
-
-  it('rejects other methods on a fixed `tunnelRoute` path instead of rendering the app', async () => {
-    setClient(undefined);
-    const entry: { fetch: (request: Request) => Response } = { fetch: appFetch };
-    const wrapped = wrapServerEntryWithSentryTunnel(entry, { path: '/monitor' });
-
-    const response = await wrapped.fetch(new Request('http://localhost:3000/monitor'));
-
-    expect(response.status).toBe(405);
-    expect(response.headers.get('allow')).toBe('POST');
-    expect(appFetch).not.toHaveBeenCalled();
-    expect(await (await wrapped.fetch(new Request('http://localhost:3000/other'))).text()).toBe('app');
-  });
-
-  it('rejects other methods on the DSN-derived tunnel path too', async () => {
-    setClient({});
-    const entry: { fetch: (request: Request) => Response } = { fetch: appFetch };
-
-    const response = await wrapServerEntryWithSentryTunnel(entry).fetch(new Request(TUNNEL_URL));
-
-    expect(response.status).toBe(405);
-    expect(response.headers.get('allow')).toBe('POST');
-    expect(appFetch).not.toHaveBeenCalled();
-  });
-
   it('passes other requests and their options to the app', async () => {
     setClient({});
     const request = makeEnvelopeRequest('http://localhost:3000/api/users');
@@ -110,39 +67,6 @@ describe('wrapServerEntryWithSentryTunnel', () => {
     expect(appFetch).toHaveBeenCalledWith(request, env, ctx);
   });
 
-  it("keeps a class instance entry's prototype handlers, like a Worker's `scheduled`", async () => {
-    setClient({});
-    class Handler {
-      public fetch(_request: Request): Response {
-        return new Response('app');
-      }
-
-      public scheduled(): string {
-        return 'scheduled';
-      }
-    }
-
-    const wrapped = wrapServerEntryWithSentryTunnel(new Handler());
-
-    expect(wrapped.scheduled()).toBe('scheduled');
-    expect(wrapped).toBeInstanceOf(Handler);
-    expect(await (await wrapped.fetch(makeEnvelopeRequest(TUNNEL_URL))).text()).toBe('forwarded');
-  });
-
-  it('wraps an entry whose prototype is frozen', async () => {
-    setClient({});
-    class Handler {
-      public fetch(_request: Request): Response {
-        return new Response('app');
-      }
-    }
-    Object.freeze(Handler.prototype);
-
-    const wrapped = wrapServerEntryWithSentryTunnel(new Handler());
-
-    expect(await (await wrapped.fetch(makeEnvelopeRequest(TUNNEL_URL))).text()).toBe('forwarded');
-  });
-
   it('returns a class entry, like a `WorkerEntrypoint`, unchanged', () => {
     class Worker {
       public fetch(): Response {
@@ -166,35 +90,4 @@ describe('wrapServerEntryWithSentryTunnel', () => {
       ),
     ).toBe(true);
   });
-
-  it('keeps the options of `serveTunnelIntegration` over `tunnelRoute`', async () => {
-    setClient({ path: '/from-init' });
-    const options = getCurrentScope().getClient()!.getOptions();
-
-    const response = await wrapServerEntryWithSentryTunnel({ fetch: appFetch }, { path: '/from-build' }).fetch(
-      makeEnvelopeRequest('http://localhost:3000/from-init'),
-    );
-
-    expect(options._managedTunnel).toEqual({ path: '/from-init' });
-    expect(await response.text()).toBe('forwarded');
-  });
-
-  it('answers the tunnel under the base path Start routes on, and only there', async () => {
-    setClient({});
-    const wrapped = wrapServerEntryWithSentryTunnel({ fetch: appFetch }, undefined, '/app');
-
-    expect(
-      await (await wrapped.fetch(makeEnvelopeRequest(`http://localhost:3000/app${getTunnelPath(DSN)}`))).text(),
-    ).toBe('forwarded');
-    expect(await (await wrapped.fetch(makeEnvelopeRequest(TUNNEL_URL))).text()).toBe('app');
-  });
-
-  it('keeps a base path `serveTunnelIntegration` set', async () => {
-    setClient({ basePath: '/custom' });
-    const wrapped = wrapServerEntryWithSentryTunnel({ fetch: appFetch }, undefined, '/app');
-
-    expect(
-      await (await wrapped.fetch(makeEnvelopeRequest(`http://localhost:3000/custom${getTunnelPath(DSN)}`))).text(),
-    ).toBe('forwarded');
-  });
 });