diff --git a/e2e/react/src/components/SponsorInfo.tsx b/e2e/react/src/components/SponsorInfo.tsx
index 0dc05b7263..f10ed92a79 100644
--- a/e2e/react/src/components/SponsorInfo.tsx
+++ b/e2e/react/src/components/SponsorInfo.tsx
@@ -1,4 +1,4 @@
-import { graphql, useFragment, type SponsorInfo } from '$houdini'
+import { graphql, type SponsorInfo, useFragment } from '$houdini'
 
 type Props = {
 	sponsor: SponsorInfo
diff --git a/packages/houdini-react/src/plugin/codegen/render.ts b/packages/houdini-react/src/plugin/codegen/render.ts
index 28593dd124..e175f8b344 100644
--- a/packages/houdini-react/src/plugin/codegen/render.ts
+++ b/packages/houdini-react/src/plugin/codegen/render.ts
@@ -24,11 +24,104 @@ export const renderToStream = render
 `
 
 	const app_index = `
+import { Router } from '$houdini/plugins/houdini-react/runtime'
 import React from 'react'
+
 import Shell from '../../../../../src/+index'
-import { Router } from '$houdini'
 
-export default (props) => <Shell><Router {...props} /></Shell>
+export default (props) => (
+	<Shell>
+		<Router {...props} />
+	</Shell>
+)
+`
+
+	let renderer = `
+	import { Cache } from '$houdini/runtime/cache/cache'
+import { serverAdapterFactory, _serverHandler } from '$houdini/runtime/router/server'
+import { HoudiniClient } from '$houdini/runtime/client'
+import { renderToStream } from 'react-streaming/server'
+import React from 'react'
+
+import { router_cache } from '../../runtime/routing'
+// @ts-expect-error
+import client from '../../../../../src/+client'
+// @ts-expect-error
+import App from './App'
+
+export const on_render =
+	({ assetPrefix, pipe, production, documentPremable }) =>
+	async ({
+		url,
+		match,
+		session,
+		manifest,
+	}) => {
+		// instanitate a cache we can use for this request
+		const cache = new Cache({ disabled: false })
+
+		if (!match) {
+			return new Response('not found', { status: 404 })
+		}
+
+		const {
+			readable,
+			injectToStream,
+			pipe: pipeTo,
+		} = await renderToStream(
+			React.createElement(App, {
+				initialURL: url,
+				cache: cache,
+				session: session,
+				assetPrefix: assetPrefix,
+				manifest: manifest,
+				...router_cache()
+			}),
+			{
+				userAgent: 'Vite',
+			}
+		)
+
+		// add the initial scripts to the page
+		injectToStream(\`
+		<script>
+			window.__houdini__initial__cache__ = \${cache.serialize()};
+			window.__houdini__initial__session__ = \${JSON.stringify(session)};
+		</script>
+
+		\${documentPremable}
+
+		<!--
+			add a virtual module that hydrates the client and sets up the initial pending cache.
+			the dynamic extension is to support dev which sees the raw jsx, and production which sees the bundled asset
+		-->
+		<script type="module" src="\${assetPrefix}/pages/\${match.id}.\${production ? 'js' : 'jsx'}" async=""></script>
+	\`)
+
+		if (pipeTo && pipe) {
+			pipeTo(pipe)
+			return true
+		} else {
+			return new Response(readable)
+		}
+	}
+
+export function reactServerHandler(options) {
+	return _serverHandler({
+		...options,
+		client,
+		on_render: on_render({ assetPrefix: options.assetPrefix, pipe: options.pipe, documentPremable: options.documentPremable }),
+	})
+}
+
+export default function createServerAdapter(options) {
+	return serverAdapterFactory({
+		client,
+		production: true,
+		...options,
+		on_render: on_render({ assetPrefix: options.assetPrefix }),
+	})
+}
 `
 
 	// and a file that adapters can import to get the local configuration
@@ -55,74 +148,9 @@ export default (props) => <Shell><Router {...props} /></Shell>
 		}
 	`
 
-	// we need a file in the local runtime that we can use to drive the server-side responses
-	const server_adapter = `
-import React from 'react'
-import { renderToStream } from 'react-streaming/server'
-import { Cache } from '$houdini/runtime/cache/cache'
-import { serverAdapterFactory } from '$houdini/runtime/router/server'
-
-import { Router, router_cache } from '../../runtime'
-import manifest from '../../runtime/manifest'
-import App from './App'
-
-import Shell from '../../../../../src/+index'
-
-export default (options) => {
-	return serverAdapterFactory({
-		manifest,
-		...options,
-		on_render: async ({url, match, session, pipe , manifest }) => {
-			// instanitate a cache we can use for this request
-			const cache = new Cache({ disabled: false })
-
-			if (!match) {
-				return new Response('not found', { status: 404 })
-			}
-
-			const { readable, injectToStream, pipe: pipeTo } = await renderToStream(
-				React.createElement(App, {
-					initialURL: url,
-					cache: cache,
-					session: session,
-					assetPrefix: options.assetPrefix,
-					manifest: manifest,
-					...router_cache()
-				}),
-				{
-					userAgent: 'Vite',
-				}
-			)
-
-			// add the initial scripts to the page
-			injectToStream(\`
-				<script>
-					window.__houdini__initial__cache__ = \${cache.serialize()};
-					window.__houdini__initial__session__ = \${JSON.stringify(session)};
-				</script>
-
-				<!--
-					add a virtual module that hydrates the client and sets up the initial pending cache.
-					the dynamic extension is to support dev which sees the raw jsx, and production which sees the bundled asset
-				-->
-				<script type="module" src="\${options.assetPrefix}/pages/\${match.id}.\${options.production ? 'js' : 'jsx'}" async=""></script>
-			\`)
-
-			if (pipe && pipeTo) {
-				// pipe the response to the client
-				pipeTo(pipe)
-			} else {
-				// and deliver our Response while that's running.
-				return new Response(readable)
-			}
-		},
-	})
-}
-	`
-
 	await Promise.all([
-		fs.writeFile(routerConventions.server_adapter_path(config), server_adapter),
 		fs.writeFile(routerConventions.adapter_config_path(config), adapter_config),
+		fs.writeFile(routerConventions.server_adapter_path(config), renderer),
 		fs.writeFile(routerConventions.app_component_path(config), app_index),
 		fs.writeFile(routerConventions.vite_render_path(config), vite_render),
 	])
diff --git a/packages/houdini-react/src/plugin/vite.tsx b/packages/houdini-react/src/plugin/vite.tsx
index 839f9d1d05..b44a304229 100644
--- a/packages/houdini-react/src/plugin/vite.tsx
+++ b/packages/houdini-react/src/plugin/vite.tsx
@@ -1,31 +1,23 @@
-import * as graphql from 'graphql'
 import { GraphQLSchema } from 'graphql'
-import { createYoga } from 'graphql-yoga'
 import {
 	PluginHooks,
 	path,
 	fs,
 	load_manifest,
-	routerConventions,
 	isSecondaryBuild,
 	type ProjectManifest,
-	type ServerAdapterFactory,
 	type YogaServer,
 	type RouterManifest,
-	find_match,
 	localApiEndpoint,
 	loadLocalSchema,
-	handle_request,
-	localApiSessionKeys,
-	get_session,
-	Cache,
-	HoudiniClient,
+	routerConventions,
+	find_match,
+	internalRoutes,
 } from 'houdini'
 import React from 'react'
-import type { BuildOptions } from 'vite'
+import type { BuildOptions, Connect } from 'vite'
 
 import { setManifest } from '.'
-import { router_cache } from '../runtime'
 import { writeTsconfig } from './codegen/typeRoot'
 
 // in order to coordinate the client and server, the client's pending request cache
@@ -172,8 +164,6 @@ export default {
 					})
 				}
 
-
-
 				// hydrate the cache with the information from the initial payload
 				window.__houdini__cache__?.hydrate(
 					window.__houdini__initial__cache__,
@@ -209,6 +199,11 @@ if (window.__houdini__nav_caches__ && window.__houdini__nav_caches__.artifact_ca
 		await writeTsconfig(server.houdiniConfig)
 
 		server.middlewares.use(async (req, res, next) => {
+			if (!req.url) {
+				next()
+				return
+			}
+
 			// import the router manifest from the runtime
 			// pull in the project's manifest
 			const { default: router_manifest } = (await server.ssrLoadModule(
@@ -218,19 +213,16 @@ if (window.__houdini__nav_caches__ && window.__houdini__nav_caches__.artifact_ca
 				)
 			)) as { default: RouterManifest<React.Component> }
 
-			const graphqlEndpoint = localApiEndpoint(server.houdiniConfig.configFile)
+			const [match] = find_match(router_manifest, req.url)
 
-			// any requests for things that aren't routes shouldn't be handled
-			try {
-				const [match] = find_match(router_manifest, req.url ?? '/')
-				if (!match) {
-					throw new Error()
-				}
-			} catch {
-				if (req.url !== graphqlEndpoint) {
-					console.log('skipping', req.url)
-					return next()
-				}
+			if (
+				!match &&
+				!internalRoutes(server.houdiniConfig.configFile).find((route) =>
+					req.url?.startsWith(route)
+				)
+			) {
+				next()
+				return
 			}
 
 			// its worth loading the project manifest
@@ -241,6 +233,7 @@ if (window.__houdini__nav_caches__ && window.__houdini__nav_caches__.artifact_ca
 			if (project_manifest.local_schema) {
 				schema = await loadLocalSchema(server.houdiniConfig)
 			}
+
 			// import the yoga server
 			let yoga: YogaServer | null = null
 			if (project_manifest.local_yoga) {
@@ -249,112 +242,77 @@ if (window.__houdini__nav_caches__ && window.__houdini__nav_caches__.artifact_ca
 					'+yoga?t=' + new Date().getTime()
 				)
 				yoga = (await server.ssrLoadModule(yogaPath)) as YogaServer
-			} else if (project_manifest.local_schema) {
-				yoga = createYoga({
-					schema: schema!,
-					landingPage: true,
-					graphqlEndpoint,
-				})
-			}
-
-			if (!req.url) {
-				next()
-				return
 			}
 
-			// pull out the desired url
-			const url = req.url
+			// load the render factory
+			const { reactServerHandler: serverHandler } = (await server.ssrLoadModule(
+				routerConventions.server_adapter_path(server.houdiniConfig) +
+					'?t=' +
+					new Date().getTime()
+			)) as { reactServerHandler: any }
 
-			console.log(yoga, url)
-			// if its a req we can process with yoga, do it.
-			if (yoga && url === localApiEndpoint(server.houdiniConfig.configFile)) {
-				console.log('yoga response')
-				return yoga(req, res)
+			const requestHeaders = new Headers()
+			for (const header of Object.entries(req.headers ?? {})) {
+				requestHeaders.set(header[0], header[1] as string)
 			}
 
-			const headers = new Headers(req.headers as Record<string, string>)
-			const session_keys = localApiSessionKeys(server.houdiniConfig.configFile)
-			// load the session information
-			const session = get_session(
-				headers,
-				localApiSessionKeys(server.houdiniConfig.configFile)
+			// wrap the vite request in a proper on
+			const request = new Request(
+				'https://localhost:5173' + req.url,
+				req.method === 'POST'
+					? {
+							method: req.method,
+							headers: requestHeaders,
+							body: await getBody(req),
+					  }
+					: undefined
 			)
 
-			// maybe its a session-related req
-			const authResponse = await handle_request({
-				url,
-				config: server.houdiniConfig.configFile,
-				session_keys,
-				headers: new Headers(Object.entries(headers)),
-			})
-			if (authResponse) {
-				return authResponse
+			for (const [key, value] of Object.entries(req.headers)) {
+				request.headers.set(key, value as string)
 			}
 
-			// the req is for a server-side rendered page
-
-			// find the matching url
-			const [match] = find_match(router_manifest, url)
-			// instanitate a cache we can use for this request
-			const cache = new Cache({ disabled: false })
-
-			if (!match) {
-				return new Response('not found', { status: 404 })
-			}
-
-			const { default: client } = (await server.ssrLoadModule(
-				path.join(server.houdiniConfig.projectRoot, 'src', '+client')
-			)) as { default: HoudiniClient }
-			const { renderToStream } = await server.ssrLoadModule(
-				routerConventions.vite_render_path(server.houdiniConfig)
-			)
-			const { default: App } = (await server.ssrLoadModule(
-				routerConventions.app_component_path(server.houdiniConfig) +
-					'?t=' +
-					new Date().getTime()
-			)) as { default: () => React.ReactElement }
-
-			if (schema) {
-				const graphqlEndpoint = localApiEndpoint(server.houdiniConfig.configFile)
-				client.registerProxy(graphqlEndpoint, async ({ query, variables, session }) => {
-					// get the parsed query
-					const parsed = graphql.parse(query)
-
-					return await graphql.execute(schema!, parsed, null, session, variables)
-				})
+			// instantiate the handler and invoke it with a mocked response
+			const result: Response = await serverHandler({
+				schema,
+				yoga,
+				production: false,
+				manifest: router_manifest,
+				graphqlEndpoint: localApiEndpoint(server.houdiniConfig.configFile),
+				assetPrefix: '/virtual:houdini',
+				pipe: res,
+				documentPremable: `<script type="module" src="/@vite/client" async=""></script>`,
+			})(request)
+			if (result && result.status === 404) {
+				next()
 			}
-
-			const { injectToStream, pipe } = await renderToStream(
-				React.createElement(App, {
-					initialURL: url,
-					cache: cache,
-					session: session,
-					assetPrefix: '/virtual:houdini',
-					manifest: manifest,
-					...router_cache(),
-				}),
-				{
-					userAgent: 'Vite',
+			// if we got here but we didn't pipe a response then we have to send the result to the end
+			if (result && typeof result !== 'boolean') {
+				if (res.closed) {
+					return
 				}
-			)
-
-			// add the initial scripts to the page
-			injectToStream(`
-	<script>
-		window.__houdini__initial__cache__ = ${cache.serialize()};
-		window.__houdini__initial__session__ = ${JSON.stringify(session)};
-	</script>
-
-	<!--
-		add a virtual module that hydrates the client and sets up the initial pending cache.
-		the dynamic extension is to support dev which sees the raw jsx, and production which sees the bundled asset
-	-->
-	<script type="module" src="/virtual:houdini/pages/${match.id}.jsx" async=""></script>
-	<!-- // <script type="module" src="\${options.assetPrefix}/pages/\${match.id}.\${options.production ? 'js' : 'jsx'}" async=""></script> ->
-`)
-
-			// start streaming the response to the user
-			pipe?.(res)
+				for (const header of Object.entries(result.headers ?? {})) {
+					res.setHeader(header[0], header[1])
+				}
+				res.write(await result.text())
+				res.end()
+			}
 		})
 	},
 } as PluginHooks['vite']
+
+// function:
+function getBody(request: Connect.IncomingMessage): Promise<string> {
+	return new Promise((resolve) => {
+		const bodyParts: Uint8Array[] = []
+		let body
+		request
+			.on('data', (chunk: Uint8Array) => {
+				bodyParts.push(chunk)
+			})
+			.on('end', () => {
+				body = Buffer.concat(bodyParts).toString()
+				resolve(body)
+			})
+	})
+}
diff --git a/packages/houdini-react/src/runtime/index.tsx b/packages/houdini-react/src/runtime/index.tsx
index 3490083d34..98dc43f806 100644
--- a/packages/houdini-react/src/runtime/index.tsx
+++ b/packages/houdini-react/src/runtime/index.tsx
@@ -1,20 +1,11 @@
 import type { Cache } from '$houdini/runtime/cache/cache'
-import { DocumentStore } from '$houdini/runtime/client'
-import { LRUCache } from '$houdini/runtime/lib/lru'
-import { GraphQLObject, GraphQLVariables, QueryArtifact } from '$houdini/runtime/lib/types'
-import React from 'react'
 
 import client from './client'
 import manifest from './manifest'
-import {
-	SuspenseCache,
-	suspense_cache,
-	Router as RouterImpl,
-	RouterContextProvider,
-	type PendingCache,
-} from './routing'
+import { Router as RouterImpl, RouterCache, RouterContextProvider } from './routing'
 
 export * from './hooks'
+export { router_cache } from './routing'
 
 export function Router({
 	cache,
@@ -47,65 +38,3 @@ export function Router({
 		</RouterContextProvider>
 	)
 }
-
-type RouterCache = {
-	artifact_cache: SuspenseCache<QueryArtifact>
-	component_cache: SuspenseCache<(props: any) => React.ReactElement>
-	data_cache: SuspenseCache<DocumentStore<GraphQLObject, GraphQLVariables>>
-	last_variables: LRUCache<GraphQLVariables>
-	pending_cache: PendingCache
-}
-
-export function router_cache({
-	pending_queries = [],
-	artifacts = {},
-	components = {},
-	initialData = {},
-	initialArtifacts = {},
-}: {
-	pending_queries?: string[]
-	artifacts?: Record<string, QueryArtifact>
-	components?: Record<string, (props: any) => React.ReactElement>
-	initialData?: Record<string, DocumentStore<GraphQLObject, GraphQLVariables>>
-	initialArtifacts?: Record<string, QueryArtifact>
-} = {}): RouterCache {
-	const result: RouterCache = {
-		artifact_cache: suspense_cache(initialArtifacts),
-		component_cache: suspense_cache(),
-		data_cache: suspense_cache(initialData),
-		pending_cache: suspense_cache(),
-		last_variables: suspense_cache(),
-	}
-
-	// we need to fill each query with an externally resolvable promise
-	for (const query of pending_queries) {
-		result.pending_cache.set(query, signal_promise())
-	}
-
-	for (const [name, artifact] of Object.entries(artifacts)) {
-		result.artifact_cache.set(name, artifact)
-	}
-
-	for (const [name, component] of Object.entries(components)) {
-		result.component_cache.set(name, component)
-	}
-
-	return result
-}
-
-// a signal promise is a promise is used to send signals by having listeners attach
-// actions to the then()
-function signal_promise(): Promise<void> & { resolve: () => void; reject: () => void } {
-	let resolve: () => void = () => {}
-	let reject: () => void = () => {}
-	const promise = new Promise<void>((res, rej) => {
-		resolve = res
-		reject = rej
-	})
-
-	return {
-		...promise,
-		resolve,
-		reject,
-	}
-}
diff --git a/packages/houdini-react/src/runtime/routing/Router.tsx b/packages/houdini-react/src/runtime/routing/Router.tsx
index 6679dfaac4..ff86e849bb 100644
--- a/packages/houdini-react/src/runtime/routing/Router.tsx
+++ b/packages/houdini-react/src/runtime/routing/Router.tsx
@@ -10,7 +10,7 @@ import React from 'react'
 import { useStream } from 'react-streaming'
 
 import { useDocumentStore } from '../hooks/useDocumentStore'
-import { SuspenseCache } from './cache'
+import { SuspenseCache, suspense_cache } from './cache'
 
 const PreloadWhich = {
 	component: 'component',
@@ -604,3 +604,65 @@ function usePreload({ preload }: { preload: (url: string, which: PreloadWhichVal
 		}
 	}, [])
 }
+
+export type RouterCache = {
+	artifact_cache: SuspenseCache<QueryArtifact>
+	component_cache: SuspenseCache<(props: any) => React.ReactElement>
+	data_cache: SuspenseCache<DocumentStore<GraphQLObject, GraphQLVariables>>
+	last_variables: LRUCache<GraphQLVariables>
+	pending_cache: PendingCache
+}
+
+export function router_cache({
+	pending_queries = [],
+	artifacts = {},
+	components = {},
+	initialData = {},
+	initialArtifacts = {},
+}: {
+	pending_queries?: string[]
+	artifacts?: Record<string, QueryArtifact>
+	components?: Record<string, (props: any) => React.ReactElement>
+	initialData?: Record<string, DocumentStore<GraphQLObject, GraphQLVariables>>
+	initialArtifacts?: Record<string, QueryArtifact>
+} = {}): RouterCache {
+	const result: RouterCache = {
+		artifact_cache: suspense_cache(initialArtifacts),
+		component_cache: suspense_cache(),
+		data_cache: suspense_cache(initialData),
+		pending_cache: suspense_cache(),
+		last_variables: suspense_cache(),
+	}
+
+	// we need to fill each query with an externally resolvable promise
+	for (const query of pending_queries) {
+		result.pending_cache.set(query, signal_promise())
+	}
+
+	for (const [name, artifact] of Object.entries(artifacts)) {
+		result.artifact_cache.set(name, artifact)
+	}
+
+	for (const [name, component] of Object.entries(components)) {
+		result.component_cache.set(name, component)
+	}
+
+	return result
+}
+
+// a signal promise is a promise is used to send signals by having listeners attach
+// actions to the then()
+function signal_promise(): Promise<void> & { resolve: () => void; reject: () => void } {
+	let resolve: () => void = () => {}
+	let reject: () => void = () => {}
+	const promise = new Promise<void>((res, rej) => {
+		resolve = res
+		reject = rej
+	})
+
+	return {
+		...promise,
+		resolve,
+		reject,
+	}
+}
diff --git a/packages/houdini/src/adapter/index.tsx b/packages/houdini/src/adapter/index.tsx
index 565d352ed3..3915ce07db 100644
--- a/packages/houdini/src/adapter/index.tsx
+++ b/packages/houdini/src/adapter/index.tsx
@@ -5,6 +5,6 @@ export const endpoint: string = ''
 export let createServerAdapter: (
 	args: Omit<
 		Parameters<typeof createAdapter>[0],
-		'on_render' | 'manifest' | 'yoga' | 'schema' | 'graphqlEndpoint'
+		'on_render' | 'manifest' | 'yoga' | 'schema' | 'graphqlEndpoint' | 'client'
 	>
 ) => ReturnType<typeof createAdapter>
diff --git a/packages/houdini/src/lib/router/server.ts b/packages/houdini/src/lib/router/server.ts
index f485f902fc..b3c8fa5f15 100644
--- a/packages/houdini/src/lib/router/server.ts
+++ b/packages/houdini/src/lib/router/server.ts
@@ -2,11 +2,21 @@ import type * as graphql from 'graphql'
 import path from 'node:path'
 
 import type { Config } from '../config'
+import { ConfigFile, localApiEndpoint } from '../types'
 
 export function isSecondaryBuild() {
 	return process.env.HOUDINI_SCHEMA_BUILD === 'true'
 }
 
+export function internalRoutes(config: ConfigFile): string[] {
+	const routes = [localApiEndpoint(config)]
+	if (config.router?.auth && 'redirect' in config.router.auth) {
+		routes.push(config.router.auth.redirect)
+	}
+
+	return routes
+}
+
 export async function buildLocalSchema(config: Config): Promise<void> {
 	// load the current version of vite
 	const { build } = await import('vite')
diff --git a/packages/houdini/src/runtime/router/server.ts b/packages/houdini/src/runtime/router/server.ts
index 281cbc6fac..2e08aca5f5 100644
--- a/packages/houdini/src/runtime/router/server.ts
+++ b/packages/houdini/src/runtime/router/server.ts
@@ -1,12 +1,11 @@
 import { createServerAdapter as createAdapter } from '@whatwg-node/server'
 import { type GraphQLSchema, parse, execute } from 'graphql'
 import { createYoga } from 'graphql-yoga'
-import type { IncomingMessage, ServerResponse } from 'node:http'
 
 // @ts-ignore
-import client from '../../../src/+client'
+import type { HoudiniClient } from '../client'
 // @ts-ignore
-import { localApiSessionKeys, localApiEndpoint, getCurrentConfig } from '../lib/config'
+import { localApiSessionKeys, localApiEndpoint, getCurrentConfig, ConfigFile } from '../lib/config'
 import { find_match } from './match'
 // @ts-ignore
 import { get_session, handle_request } from './session'
@@ -15,31 +14,30 @@ import type { RouterManifest, RouterPageManifest, YogaServerOptions } from './ty
 // load the plugin config
 const config_file = getCurrentConfig()
 const session_keys = localApiSessionKeys(config_file)
-const graphqlEndpoint = localApiEndpoint(config_file)
 
-export const serverAdapterFactory = <ComponentType>({
+export function _serverHandler<ComponentType = unknown>({
 	schema,
 	yoga,
+	client,
 	production,
 	manifest,
+	graphqlEndpoint,
 	on_render,
-	pipe,
-	assetPrefix,
 }: {
 	schema?: GraphQLSchema | null
 	yoga?: ReturnType<typeof createYoga> | null
+	client: HoudiniClient
+	production: boolean
+	manifest: RouterManifest<ComponentType> | null
 	assetPrefix: string
-	production?: boolean
-	pipe?: ServerResponse<IncomingMessage>
+	graphqlEndpoint: string
 	on_render: (args: {
 		url: string
 		match: RouterPageManifest<ComponentType> | null
-		manifest: RouterManifest<unknown>
+		manifest: RouterManifest<ComponentType>
 		session: App.Session
-		pipe?: ServerResponse<IncomingMessage>
-	}) => Response | Promise<Response>
-	manifest: RouterManifest<ComponentType> | null
-} & Omit<YogaServerOptions, 'schema'>): ReturnType<typeof createAdapter> => {
+	}) => Response | Promise<Response | undefined> | undefined
+} & Omit<YogaServerOptions, 'schema'>) {
 	if (schema && !yoga) {
 		yoga = createYoga({
 			schema,
@@ -48,19 +46,16 @@ export const serverAdapterFactory = <ComponentType>({
 		})
 	}
 
-	// @ts-ignore: schema is defined dynamically
 	if (schema) {
-		// @ts-ignore: graphqlEndpoint is defined dynamically
 		client.registerProxy(graphqlEndpoint, async ({ query, variables, session }) => {
 			// get the parsed query
 			const parsed = parse(query)
 
-			// @ts-ignore: schema is defined dynamically
 			return await execute(schema, parsed, null, session, variables)
 		})
 	}
 
-	return createAdapter(async (request) => {
+	return async (request: Request) => {
 		if (!manifest) {
 			return new Response(
 				"Adapter did not provide the project's manifest. Please open an issue on github.",
@@ -98,7 +93,6 @@ export const serverAdapterFactory = <ComponentType>({
 			match,
 			session: await get_session(request.headers, session_keys),
 			manifest,
-			pipe,
 		})
 		if (rendered) {
 			return rendered
@@ -106,7 +100,13 @@ export const serverAdapterFactory = <ComponentType>({
 
 		// if we got this far its not a page we recognize
 		return new Response('404', { status: 404 })
-	})
+	}
+}
+
+export const serverAdapterFactory = (
+	args: Parameters<typeof _serverHandler>[0]
+): ReturnType<typeof createAdapter> => {
+	return createAdapter(_serverHandler(args))
 }
 
 export type ServerAdapterFactory = typeof serverAdapterFactory
diff --git a/packages/houdini/src/vite/houdini.ts b/packages/houdini/src/vite/houdini.ts
index 3e6e660cf5..f2329048ed 100644
--- a/packages/houdini/src/vite/houdini.ts
+++ b/packages/houdini/src/vite/houdini.ts
@@ -18,6 +18,7 @@ import {
 let config: Config
 let viteConfig: ResolvedConfig
 let viteEnv: ConfigEnv
+let devServer = false
 
 export default function Plugin(opts: PluginConfig = {}): VitePlugin {
 	return {
@@ -93,7 +94,7 @@ export default function Plugin(opts: PluginConfig = {}): VitePlugin {
 			}
 
 			// if we dont' have an adapter, we don't need to do anything
-			if (!opts.adapter) {
+			if (!opts.adapter || devServer) {
 				return
 			}
 
@@ -120,7 +121,7 @@ export default function Plugin(opts: PluginConfig = {}): VitePlugin {
 				publicBase: viteConfig.base,
 				outDir: config.routerBuildDirectory,
 				manifest,
-				adapterPath: '../$houdini/plugins/houdini-react/units/render/config.js',
+				adapterPath: '../$houdini/plugins/houdini-react/units/render/server.js',
 			})
 
 			// if there is a public directory at the root of the project,
@@ -183,6 +184,8 @@ export default function Plugin(opts: PluginConfig = {}): VitePlugin {
 		},
 
 		async configureServer(server) {
+			devServer = true
+
 			for (const plugin of config.plugins) {
 				if (typeof plugin.vite?.configureServer !== 'function') {
 					continue