diff --git a/.changeset/shy-months-watch.md b/.changeset/shy-months-watch.md
new file mode 100644
index 0000000000..471bd89c29
--- /dev/null
+++ b/.changeset/shy-months-watch.md
@@ -0,0 +1,6 @@
+---
+'houdini': patch
+'houdini-svelte': patch
+---
+
+Added typescript codegen
diff --git a/e2e/sveltekit/src/routes/plugin/+layout.ts b/e2e/sveltekit/src/routes/plugin/+layout.ts
index 4ad8ed4e66..e5c4880609 100644
--- a/e2e/sveltekit/src/routes/plugin/+layout.ts
+++ b/e2e/sveltekit/src/routes/plugin/+layout.ts
@@ -1,4 +1,6 @@
 // don't delete this. It's here as a way to verify some behavior on the session test
 export async function load() {
-  return {};
+  return {
+    test: 'test'
+  };
 }
diff --git a/e2e/sveltekit/src/routes/stores/partial/partial_List/+page.svelte b/e2e/sveltekit/src/routes/stores/partial/partial_List/+page.svelte
index cca5ee42a6..372e63209f 100644
--- a/e2e/sveltekit/src/routes/stores/partial/partial_List/+page.svelte
+++ b/e2e/sveltekit/src/routes/stores/partial/partial_List/+page.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import type { PageData } from './$types';
+  import type { PageData } from './$houdini';
   export let data: PageData;
 
   $: ({ Partial_List } = data);
diff --git a/e2e/sveltekit/src/routes/stores/partial/partial_[userId]/+page.svelte b/e2e/sveltekit/src/routes/stores/partial/partial_[userId]/+page.svelte
index 62e54ec5a9..785decb065 100644
--- a/e2e/sveltekit/src/routes/stores/partial/partial_[userId]/+page.svelte
+++ b/e2e/sveltekit/src/routes/stores/partial/partial_[userId]/+page.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import type { PageData } from './$types';
+  import type { PageData } from './$houdini';
 
   export let data: PageData;
 
diff --git a/e2e/sveltekit/src/routes/stores/partial/partial_[userId]_Light/+page.svelte b/e2e/sveltekit/src/routes/stores/partial/partial_[userId]_Light/+page.svelte
index 1e71ae7739..c6ddea266d 100644
--- a/e2e/sveltekit/src/routes/stores/partial/partial_[userId]_Light/+page.svelte
+++ b/e2e/sveltekit/src/routes/stores/partial/partial_[userId]_Light/+page.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import type { PageData } from './$types';
+  import type { PageData } from './$houdini';
 
   export let data: PageData;
 
diff --git a/e2e/sveltekit/src/routes/stores/ssr-[userId]/+page.svelte b/e2e/sveltekit/src/routes/stores/ssr-[userId]/+page.svelte
index d1a674071a..47ca78e720 100644
--- a/e2e/sveltekit/src/routes/stores/ssr-[userId]/+page.svelte
+++ b/e2e/sveltekit/src/routes/stores/ssr-[userId]/+page.svelte
@@ -2,7 +2,7 @@
   import { CachePolicy } from '$houdini';
   import { page } from '$app/stores';
   import { stry } from '@kitql/helper';
-  import type { PageData } from './$types';
+  import type { PageData } from './$houdini';
 
   export let data: PageData;
 
diff --git a/e2e/sveltekit/src/routes/stores/ssr-one-store-multivariables/+page.svelte b/e2e/sveltekit/src/routes/stores/ssr-one-store-multivariables/+page.svelte
index 41981cee6f..25cd82c99a 100644
--- a/e2e/sveltekit/src/routes/stores/ssr-one-store-multivariables/+page.svelte
+++ b/e2e/sveltekit/src/routes/stores/ssr-one-store-multivariables/+page.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import { MultiUserStore } from '$houdini';
-  import type { PageData } from './$types';
+  import type { PageData } from './$houdini';
 
   export let data: PageData;
 
diff --git a/e2e/sveltekit/src/routes/stores/ssr/+page.svelte b/e2e/sveltekit/src/routes/stores/ssr/+page.svelte
index 77fe8801e6..889a1f974c 100644
--- a/e2e/sveltekit/src/routes/stores/ssr/+page.svelte
+++ b/e2e/sveltekit/src/routes/stores/ssr/+page.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import type { PageData } from './$types';
+  import type { PageData } from './$houdini';
 
   export let data: PageData;
   $: ({ usersList, Hello } = data);
diff --git a/package.json b/package.json
index a2279dc01e..aa5111a011 100755
--- a/package.json
+++ b/package.json
@@ -29,11 +29,11 @@
 		"@changesets/changelog-github": "^0.4.7",
 		"@changesets/cli": "^2.25.0",
 		"@playwright/test": "1.25.0",
-		"playwright-core": "1.25.0",
 		"@theguild/eslint-config": "^0.1.0",
 		"@trivago/prettier-plugin-sort-imports": "^3.3.0",
 		"eslint-plugin-unused-imports": "^2.0.0",
 		"graphql": "^15.8.0",
+		"playwright-core": "1.25.0",
 		"prettier": "^2.7.0",
 		"turbo": "^1.5.4",
 		"vite": "^3.1.6",
diff --git a/packages/houdini-svelte/src/plugin/codegen/routes/index.ts b/packages/houdini-svelte/src/plugin/codegen/routes/index.ts
index 88b77f114e..520f8acdd2 100644
--- a/packages/houdini-svelte/src/plugin/codegen/routes/index.ts
+++ b/packages/houdini-svelte/src/plugin/codegen/routes/index.ts
@@ -1,13 +1,12 @@
 import { OperationDefinitionNode } from 'graphql'
 import { Config, fs, GenerateHookInput, path } from 'houdini'
 
-import { extract_load_function } from '../../extractLoadFunction'
 import {
 	type_route_dir,
-	walk_routes,
 	stores_directory_name,
 	store_suffix,
 	Framework,
+	walk_routes,
 } from '../../kit'
 
 export default async function svelteKitGenerator(
@@ -20,69 +19,27 @@ export default async function svelteKitGenerator(
 		return
 	}
 
-	// we need to walk down their route directory and create any variable definitions we need
 	await walk_routes(config, framework, {
 		async route({
 			dirpath,
-			pageScript,
-			layoutScript,
-			routePageQuery,
-			routeLayoutQuery,
-			inlineLayoutQueries,
-			inlineQueries,
+			svelteTypeFilePath,
+			layoutQueries,
+			pageQueries,
+			layoutExports,
+			pageExports,
 		}) {
-			// in order to create the variable definition we need to know every query that is being
-			// used in a specific route so we can generate versions of the variable functions with
-			// the Params type from './$types' provided by the sveltekit rootDir
-
-			let scriptPageExports: string[] = []
-			let scriptLayoutExports: string[] = []
-
-			const pageQueries = inlineQueries.concat(routePageQuery ?? [])
-			const layoutQueries = inlineLayoutQueries.concat(routeLayoutQuery ?? [])
-
-			// pageScript need to be imported so we can figure out if there is a houdini_load
-			// and what's inside.
-			if (pageScript) {
-				// import the houdini_load function
-				const { houdini_load, exports } = await extract_load_function(config, pageScript)
-
-				// add every load to the list
-				pageQueries.push(...(houdini_load ?? []))
-				scriptPageExports = exports
-			}
-
-			// pageScript need to be imported so we can figure out if there is a houdini_load
-			// and what's inside.
-			if (layoutScript) {
-				// import the houdini_load function
-				const { houdini_load, exports } = await extract_load_function(config, layoutScript)
-
-				// add every load to the list
-				layoutQueries.push(...(houdini_load ?? []))
-				scriptLayoutExports = exports
-			}
-
-			// if we have no queries, there's nothing to do
-			if (pageQueries.length === 0 && layoutQueries.length === 0) {
-				return
-			}
-
-			// we need to write the type defs to the same route path relative to the type root
-			// const targetPath = path.join(config.typeRouteDir,
+			//remove testing later
 			const relativePath = path.relative(config.routesDir, dirpath)
 			const target = path.join(type_route_dir(config), relativePath, config.typeRootFile)
 
-			// we can't import from $houdini so we need to compute the relative path from the import
 			const houdiniRelative = path.relative(target, config.typeRootDir)
 
-			// the unique set of query names
 			const queryNames: string[] = []
-			const uniqueQueries: OperationDefinitionNode[] = []
+			const uniquePageQueries: OperationDefinitionNode[] = []
 			for (const query of pageQueries) {
 				if (!queryNames.includes(query.name!.value)) {
 					queryNames.push(query.name!.value)
-					uniqueQueries.push(query)
+					uniquePageQueries.push(query)
 				}
 			}
 
@@ -95,95 +52,179 @@ export default async function svelteKitGenerator(
 				}
 			}
 
-			// we need to create a typescript file that has a definition of the variable and hook functions
-			const typeDefs = getTypeDefs(
-				houdiniRelative,
-				config,
-				uniqueQueries,
-				pageQueries,
-				uniqueLayoutQueries,
-				layoutQueries,
-				scriptPageExports,
-				scriptLayoutExports
-			)
-
-			// make sure we have a home for the directory
-			await fs.mkdirp(path.dirname(target))
-
-			// write the file
-			await fs.writeFile(target, typeDefs)
+			// read the svelte-kit $types.d.ts file into a string
+			let skTypeString = await fs.readFile(svelteTypeFilePath)
+
+			//if the file is truthy (not empty)
+			if (skTypeString) {
+				//get the type imports for file
+
+				const pageTypeImports = getTypeImports(houdiniRelative, config, uniquePageQueries)
+				const layoutTypeImports = getTypeImports(
+					houdiniRelative,
+					config,
+					uniqueLayoutQueries
+				)
+
+				// Util bools for ensuring no unnecessary types
+				const afterPageLoad = pageExports.includes('afterLoad')
+				const beforePageLoad = pageExports.includes('beforeLoad')
+				const onPageError = pageExports.includes('onError')
+
+				const afterLayoutLoad = layoutExports.includes('afterLoad')
+				const beforeLayoutLoad = layoutExports.includes('beforeLoad')
+				const onLayoutError = layoutExports.includes('onError')
+
+				//check if either page or layout has variables exported.
+				const pageVariableLoad = pageExports.some((x) => x.endsWith('Variables'))
+				const layoutVariableLoad = layoutExports.some((x) => x.endsWith('Variables'))
+
+				//default sktype string is defined as imports \n\n utility \n\n exports
+				const splitString = skTypeString.split('\n\n')
+
+				//name our sections
+				let typeImports = splitString[0]
+				let utilityTypes = splitString[1]
+				let typeExports = splitString[2]
+
+				// lots of comparisons but helpful to prevent unnecessary imports
+				// define function imports e.g. import {VariableFunction, AferLoadFunction, BeforeLoadFunction} from 'relativePath'
+				// will not include unnecessary imports.
+				const functionImports = `${
+					afterPageLoad ||
+					beforePageLoad ||
+					afterLayoutLoad ||
+					beforeLayoutLoad ||
+					pageVariableLoad ||
+					layoutVariableLoad
+						? `\nimport type { ${
+								layoutVariableLoad || pageVariableLoad ? 'VariableFunction, ' : ''
+						  }${afterLayoutLoad || afterPageLoad ? 'AfterLoadFunction, ' : ''}${
+								beforeLayoutLoad || beforePageLoad ? 'BeforeLoadFunction ' : ''
+						  }} from '${houdiniRelative}/plugins/houdini-svelte/runtime/types';`
+						: ''
+				}`
+
+				// mutate typeImports with our functionImports, layout/pageStores, $result, $input,
+				typeImports = typeImports
+					.concat(functionImports)
+					.concat(layoutTypeImports)
+					.concat(pageTypeImports)
+
+				// if we need Page/LayoutParams, generate this type.
+				// verify if necessary. might not be.
+				const layoutParams = `${
+					layoutQueries.length > 0 && !utilityTypes.includes('LayoutParams')
+						? "\ntype LayoutParams = LayoutLoadEvent['params'];"
+						: ''
+				}`
+
+				//page params are necessary though.
+				const pageParams = `${
+					pageQueries.length > 0 && !utilityTypes.includes('PageParams')
+						? "\ntype PageParams = PageLoadEvent['params'];"
+						: ''
+				}`
+
+				// mutate utilityTypes with our layoutParams, pageParams.
+				utilityTypes = utilityTypes
+					.concat(layoutParams)
+					.concat(pageParams)
+					//replace all instances of $types.js with $houdini to ensure type inheritence.
+					//any type imports will always be in the utilityTypes block
+					.replaceAll(/\$types\.js/gm, '$houdini')
+
+				// main bulk of the work done here.
+				typeExports = typeExports
+					//we define the loadInput, checks if any queries have imports
+					.concat(append_loadInput(layoutQueries))
+					.concat(append_loadInput(pageQueries))
+					//define beforeLoad and afterLoad types layout always first
+					.concat(append_beforeLoad(beforeLayoutLoad))
+					.concat(append_beforeLoad(beforePageLoad))
+					.concat(append_afterLoad('Layout', afterLayoutLoad, layoutQueries))
+					.concat(append_afterLoad('Page', afterPageLoad, pageQueries))
+					.concat(
+						append_onError(
+							onPageError,
+							//if there are not inputs to any query, we won't define a LoadInput in our error type
+							pageQueries.filter((x) => x.variableDefinitions?.length).length > 0
+						)
+					)
+					.concat(
+						append_onError(
+							onLayoutError,
+							//if there are not inputs to any query, we won't define a LoadInput in our error type
+							pageQueries.filter((x) => x.variableDefinitions?.length).length > 0
+						)
+					)
+					.concat(append_VariablesFunction('Layout', config, uniqueLayoutQueries))
+					.concat(append_VariablesFunction('Page', config, uniquePageQueries))
+					//match all between 'LayoutData =' and ';' and combine additional types
+					.replace(
+						//regex to append our generated stores to the existing
+						//match all between 'LayoutData =' and ';' and combine additional types
+						/(?<=LayoutData = )([\s\S]*?)(?=;)/,
+						`Expand<$1 & { ${layoutQueries
+							.map((query) => {
+								const name = query.name!.value
+
+								return [name, name + store_suffix(config)].join(': ')
+							})
+							.join('; ')} }${internal_append_TypeDataExtra(
+							beforeLayoutLoad,
+							afterLayoutLoad,
+							onLayoutError
+						)}>`
+					)
+					.replace(
+						//regex to append our generated stores to the existing
+						//match all between 'PageData =' and ';' and combine additional types
+						/(?<=PageData = )([\s\S]*?)(?=;)/,
+						`Expand<$1 & { ${pageQueries
+							.map((query) => {
+								const name = query.name!.value
+
+								return [name, name + store_suffix(config)].join(': ')
+							})
+							.join('; ')} }${internal_append_TypeDataExtra(
+							beforePageLoad,
+							afterPageLoad,
+							onPageError
+						)}>`
+					)
+
+				//make dir of target if not exist
+				await fs.mkdirp(path.dirname(target))
+				// write the file
+				await fs.writeFile(target, [typeImports, utilityTypes, typeExports].join('\n\n'))
+
+				if (typeExports.includes('proxy')) {
+					const proxyDir = path.dirname(svelteTypeFilePath)
+					const proxyDirContent = await fs.readdir(proxyDir)
+					const proxyFiles = proxyDirContent.filter((name) => name.includes('proxy'))
+					for (const element of proxyFiles) {
+						const src = path.join(proxyDir, element)
+						const dest = path.join(path.dirname(target), element)
+						await fs.copyFile(src, dest)
+					}
+				}
+			}
 		},
 	})
 }
 
-function getTypeDefs(
+function getTypeImports(
 	houdiniRelative: string,
 	config: Config,
-	uniqueQueries: OperationDefinitionNode[],
-	pageQueries: OperationDefinitionNode[],
-	uniqueLayoutQueries: OperationDefinitionNode[],
-	layoutQueries: OperationDefinitionNode[],
-	scriptPageExports: string[],
-	scriptLayoutExports: string[]
+	queries: OperationDefinitionNode[]
 ) {
-	const afterPageLoad = scriptPageExports.includes('afterLoad')
-	const beforePageLoad = scriptPageExports.includes('beforeLoad')
-	const onPageError = scriptPageExports.includes('onError')
-
-	const afterLayoutLoad = scriptLayoutExports.includes('afterLoad')
-	const beforeLayoutLoad = scriptLayoutExports.includes('beforeLoad')
-	const onLayoutError = scriptLayoutExports.includes('onError')
-
-	return `import type * as Kit from '@sveltejs/kit';
-import type { VariableFunction, AfterLoadFunction, BeforeLoadFunction }  from '${houdiniRelative}/plugins/houdini-svelte/runtime/types'
-${
-	pageQueries.length > 0
-		? `import type { PageLoadEvent, PageData as KitPageData } from './$types'`
-		: ``
-}
-${
-	layoutQueries.length > 0
-		? `import type { LayoutLoadEvent, LayoutData as KitPageData } from './$types'`
-		: ``
-}
-
-${append_Store(houdiniRelative, config, uniqueQueries)}
-${append_Store(houdiniRelative, config, uniqueLayoutQueries)}
-
-${pageQueries.length > 0 ? `type PageParams = PageLoadEvent['params']` : ``}
-${layoutQueries.length > 0 ? `type LayoutParams = LayoutLoadEvent['params']` : ``}
-
-${append_VariablesFunction('Page', config, uniqueQueries)}
-${append_VariablesFunction('Layout', config, uniqueLayoutQueries)}
-
-${append_afterLoad('Page', afterPageLoad, pageQueries)}
-${append_beforeLoad(beforePageLoad)}
-${append_onError(onPageError)}
-${append_afterLoad('Layout', afterLayoutLoad, layoutQueries)}
-${append_beforeLoad(beforeLayoutLoad)}
-${append_onError(onLayoutError)}
-
-${append_TypeData(
-	config,
-	layoutQueries,
-	'Layout',
-	beforeLayoutLoad,
-	afterLayoutLoad,
-	onLayoutError
-)}
-${append_TypeData(config, pageQueries, 'Page', beforePageLoad, afterPageLoad, onPageError)}
-`
-}
-
-function append_Store(houdiniRelative: string, config: Config, queries: OperationDefinitionNode[]) {
 	return queries
 		.map((query) => {
 			const name = query.name!.value
-
-			return `import { ${name}$result, ${name}$input } from '${houdiniRelative}/${
+			return `\nimport { ${name}$result, ${name}$input } from '${houdiniRelative}/${
 				config.artifactDirectoryName
-			}/${name}'
-	import { ${name}Store } from '${houdiniRelative}/plugins/houdini-svelte/${stores_directory_name()}/${name}'`
+			}/${name}';\nimport { ${name}Store } from '${houdiniRelative}/plugins/houdini-svelte/${stores_directory_name()}/${name}';`
 		})
 		.join('\n')
 }
@@ -201,13 +242,29 @@ function append_VariablesFunction(
 				return ''
 			}
 
-			return `export type ${config.variableFunctionName(
+			return `\nexport type ${config.variableFunctionName(
 				name
-			)} = VariableFunction<${type}Params, ${name}$input>`
+			)} = VariableFunction<${type}Params, ${name}$input>;`
 		})
 		.join('\n')
 }
 
+function append_loadInput(queries: OperationDefinitionNode[]) {
+	return `${
+		queries.filter((q) => q.variableDefinitions?.length).length
+			? `\ntype LoadInput = { ${queries
+					.filter((query) => query.variableDefinitions?.length)
+					.map((query) => {
+						// if the query does not have any variables, don't include anything
+						const name = query.name!.value
+
+						return [name, name + '$input'].join(': ')
+					})
+					.join('; ')} };`
+			: ''
+	}`
+}
+
 function append_afterLoad(
 	type: `Page` | `Layout`,
 	afterLoad: boolean,
@@ -215,22 +272,17 @@ function append_afterLoad(
 ) {
 	return afterLoad
 		? `
-	type AfterLoadReturn = ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>;
-
-	type AfterLoadData = {
-		${internal_append_afterLoad(queries)}
-	}
-
-	type LoadInput = {
-		${internal_append_afterLoadInput(queries)}
-	}
-
-	export type AfterLoadEvent = {
-		event: PageLoadEvent
-		data: AfterLoadData
-		input: LoadInput
-	}
-	`
+type AfterLoadReturn = ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>;
+type AfterLoadData = {
+	${internal_append_afterLoad(queries)}
+};
+
+export type AfterLoadEvent = {
+	event: PageLoadEvent
+	data: AfterLoadData
+	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? 'LoadInput' : '{}'}
+};
+`
 		: ''
 }
 
@@ -242,66 +294,31 @@ function internal_append_afterLoad(queries: OperationDefinitionNode[]) {
 
 			return [name, name + '$result'].join(': ')
 		})
-		.join(', \n')}`
-}
-
-function internal_append_afterLoadInput(queries: OperationDefinitionNode[]) {
-	return `${queries
-		.filter((query) => query.variableDefinitions?.length)
-		.map((query) => {
-			// if the query does not have any variables, don't include anything
-			const name = query.name!.value
-
-			return [name, name + '$input'].join(': ')
-		})
-		.join(', \n')}`
+		.join(';\n\t')}`
 }
 
 function append_beforeLoad(beforeLoad: boolean) {
 	return beforeLoad
 		? `
-export type BeforeLoadEvent = PageLoadEvent
-
+export type BeforeLoadEvent = PageLoadEvent;
 type BeforeLoadReturn = ReturnType<typeof import('./+page').beforeLoad>;
 `
 		: ''
 }
 
-function append_onError(onError: boolean) {
+function append_onError(onError: boolean, hasLoadInput: boolean) {
 	return onError
 		? `
-export type OnErrorEvent =  { event: LoadEvent, input: LoadInput, error: Error | Error[] }
-
 type OnErrorReturn = ReturnType<typeof import('./+page').onError>;
+export type OnErrorEvent =  { event: Kit.LoadEvent, input: ${
+				hasLoadInput ? 'LoadInput' : '{}'
+		  }, error: Error | Error[] };
 `
 		: ''
 }
 
-function append_TypeData(
-	config: Config,
-	queries: OperationDefinitionNode[],
-	type: `Page` | `Layout`,
-	beforeLoad: boolean,
-	afterLoad: boolean,
-	onError: boolean
-) {
-	if (queries.length === 0) {
-		return ''
-	}
-
-	return `export type ${type}Data = {
-		${queries
-			.map((query) => {
-				const name = query.name!.value
-
-				return [name, name + store_suffix(config)].join(': ')
-			})
-			.join(', \n')}
-} ${internal_append_TypeDataExtra(beforeLoad, afterLoad, onError)}`
-}
-
 function internal_append_TypeDataExtra(beforeLoad: boolean, afterLoad: boolean, onError: boolean) {
-	return `${beforeLoad ? '& BeforeLoadReturn ' : ''} ${afterLoad ? '& AfterLoadReturn ' : ''}  ${
-		onError ? '& OnErrorReturn ' : ''
+	return `${beforeLoad ? ' & BeforeLoadReturn' : ''}${afterLoad ? ' & AfterLoadReturn' : ''}${
+		onError ? ' & OnErrorReturn' : ''
 	}`
 }
diff --git a/packages/houdini-svelte/src/plugin/codegen/routes/kit.test.ts b/packages/houdini-svelte/src/plugin/codegen/routes/kit.test.ts
index 34b5a670de..3c059e2d12 100644
--- a/packages/houdini-svelte/src/plugin/codegen/routes/kit.test.ts
+++ b/packages/houdini-svelte/src/plugin/codegen/routes/kit.test.ts
@@ -24,6 +24,33 @@ test('generates types for inline queries', async function () {
 		},
 	})
 
+	await fs.mock({
+		[path.join(config.projectRoot, '.svelte-kit')]: {
+			types: {
+				src: {
+					routes: {
+						myProfile: {
+							'$types.d.ts': `import type * as Kit from '@sveltejs/kit';
+
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+type RouteParams = {  }
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;
+type PageParentData = EnsureDefined<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageData = Expand<PageParentData>;
+`,
+						},
+					},
+				},
+			},
+		},
+	})
+
 	// execute the generator
 	await generate({ config, documents: [], framework: 'kit', plugin_root })
 
@@ -31,22 +58,44 @@ test('generates types for inline queries', async function () {
 	const queryContents = await fs.readFile(
 		path.join(path.join(type_route_dir(config), 'myProfile', '$houdini.d.ts'))
 	)
+
 	expect(queryContents).toBeTruthy()
 
+	//the parser doesn't work right but the type imports are correct.
 	const parsedQuery = (await parseJS(queryContents!))?.script
+
 	// verify contents
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		import type * as Kit from "@sveltejs/kit";
-		import type { VariableFunction, AfterLoadFunction, BeforeLoadFunction } from "../../../../plugins/houdini-svelte/runtime/types";
-		import type { PageLoadEvent, PageData as KitPageData } from "./$types";
-		import { MyInlineQuery$result, MyInlineQuery$input } from "../../../../artifacts/MyInlineQuery";
-		import { MyInlineQueryStore } from "../../../../plugins/houdini-svelte/stores/MyInlineQuery";
-		type PageParams = PageLoadEvent["params"];
-
-		export type PageData = {
-		    MyInlineQuery: MyInlineQueryStore
-		};
-	`)
+	expect(parsedQuery).toMatchInlineSnapshot(`import type * as Kit from "@sveltejs/kit";
+import { MyInlineQuery$result, MyInlineQuery$input } from "../../../../artifacts/MyInlineQuery";
+import { MyInlineQueryStore } from "../../../../plugins/houdini-svelte/stores/MyInlineQuery";
+
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+
+export type RequiredKeys<T> = {
+    [K in keyof T]?: {} extends {
+        [P in K]: T[K];
+    } ? never : K;
+}[keyof T];
+
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>;
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? {
+    [P in Exclude<A, keyof U>]?: never;
+} & U : never;
+
+type PageParentData = EnsureDefined<import("../$houdini").LayoutData>;
+type PageParams = PageLoadEvent["params"];
+export type PageServerData = null;
+
+export type PageData = Expand<Expand<PageParentData> & {
+    MyInlineQuery: MyInlineQueryStore
+}>;`)
 })
 
 test('generates types for page queries', async function () {
@@ -65,6 +114,33 @@ query MyPageQuery {
 		},
 	})
 
+	await fs.mock({
+		[path.join(config.projectRoot, '.svelte-kit')]: {
+			types: {
+				src: {
+					routes: {
+						myProfile: {
+							'$types.d.ts': `import type * as Kit from '@sveltejs/kit';
+
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+type RouteParams = {  }
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;
+type PageParentData = EnsureDefined<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageData = Expand<PageParentData>;
+`,
+						},
+					},
+				},
+			},
+		},
+	})
+
 	// execute the generator
 	await generate({ config, documents: [], framework: 'kit', plugin_root })
 
@@ -75,19 +151,39 @@ query MyPageQuery {
 	expect(queryContents).toBeTruthy()
 
 	const parsedQuery = (await parseJS(queryContents!))?.script
-	// verify contents
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		import type * as Kit from "@sveltejs/kit";
-		import type { VariableFunction, AfterLoadFunction, BeforeLoadFunction } from "../../../../plugins/houdini-svelte/runtime/types";
-		import type { PageLoadEvent, PageData as KitPageData } from "./$types";
-		import { MyPageQuery$result, MyPageQuery$input } from "../../../../artifacts/MyPageQuery";
-		import { MyPageQueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageQuery";
-		type PageParams = PageLoadEvent["params"];
-
-		export type PageData = {
-		    MyPageQuery: MyPageQueryStore
-		};
-	`)
+
+	//verify contents
+	expect(parsedQuery).toMatchInlineSnapshot(`import type * as Kit from "@sveltejs/kit";
+import { MyPageQuery$result, MyPageQuery$input } from "../../../../artifacts/MyPageQuery";
+import { MyPageQueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageQuery";
+
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+
+export type RequiredKeys<T> = {
+    [K in keyof T]?: {} extends {
+        [P in K]: T[K];
+    } ? never : K;
+}[keyof T];
+
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>;
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? {
+    [P in Exclude<A, keyof U>]?: never;
+} & U : never;
+
+type PageParentData = EnsureDefined<import("../$houdini").LayoutData>;
+type PageParams = PageLoadEvent["params"];
+export type PageServerData = null;
+
+export type PageData = Expand<Expand<PageParentData> & {
+    MyPageQuery: MyPageQueryStore
+}>;`)
 })
 
 test('generates types for layout queries', async function () {
@@ -106,6 +202,34 @@ query MyLayoutQuery {
 		},
 	})
 
+	await fs.mock({
+		[path.join(config.projectRoot, '.svelte-kit')]: {
+			types: {
+				src: {
+					routes: {
+						myProfile: {
+							'$types.d.ts': `import type * as Kit from '@sveltejs/kit';
+
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+type RouteParams = {  }
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;
+type LayoutParams = RouteParams & {  }
+type LayoutParentData = EnsureDefined<{}>;
+
+export type LayoutServerData = null;
+export type LayoutData = Expand<LayoutParentData>;
+`,
+						},
+					},
+				},
+			},
+		},
+	})
+
 	// execute the generator
 	await generate({ config, documents: [], framework: 'kit', plugin_root })
 
@@ -117,18 +241,38 @@ query MyLayoutQuery {
 
 	const parsedQuery = (await parseJS(queryContents!))?.script
 	// verify contents
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		import type * as Kit from "@sveltejs/kit";
-		import type { VariableFunction, AfterLoadFunction, BeforeLoadFunction } from "../../../../plugins/houdini-svelte/runtime/types";
-		import type { LayoutLoadEvent, LayoutData as KitPageData } from "./$types";
-		import { MyLayoutQuery$result, MyLayoutQuery$input } from "../../../../artifacts/MyLayoutQuery";
-		import { MyLayoutQueryStore } from "../../../../plugins/houdini-svelte/stores/MyLayoutQuery";
-		type LayoutParams = LayoutLoadEvent["params"];
-
-		export type LayoutData = {
-		    MyLayoutQuery: MyLayoutQueryStore
-		};
-	`)
+	expect(parsedQuery).toMatchInlineSnapshot(`import type * as Kit from "@sveltejs/kit";
+import { MyLayoutQuery$result, MyLayoutQuery$input } from "../../../../artifacts/MyLayoutQuery";
+import { MyLayoutQueryStore } from "../../../../plugins/houdini-svelte/stores/MyLayoutQuery";
+
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+
+export type RequiredKeys<T> = {
+    [K in keyof T]?: {} extends {
+        [P in K]: T[K];
+    } ? never : K;
+}[keyof T];
+
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>;
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? {
+    [P in Exclude<A, keyof U>]?: never;
+} & U : never;
+
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureDefined<{}>;
+export type LayoutServerData = null;
+
+export type LayoutData = Expand<Expand<LayoutParentData> & {
+    MyLayoutQuery: MyLayoutQueryStore
+}>;
+`)
 })
 
 test('generates types for after load', async function () {
@@ -163,6 +307,35 @@ test('generates types for after load', async function () {
 		},
 	})
 
+	await fs.mock({
+		[path.join(config.projectRoot, '.svelte-kit')]: {
+			types: {
+				src: {
+					routes: {
+						myProfile: {
+							'$types.d.ts': `import type * as Kit from '@sveltejs/kit';
+
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+type RouteParams = {  }
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;
+type PageParentData = EnsureDefined<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageLoad<OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Expand<Omit<PageParentData, keyof PageParentData & EnsureDefined<PageServerData>> & OptionalUnion<EnsureDefined<PageParentData & EnsureDefined<PageServerData>>>>;
+`,
+						},
+					},
+				},
+			},
+		},
+	})
+
 	// execute the generator
 	await generate({ config, documents: [], framework: 'kit', plugin_root })
 
@@ -172,39 +345,66 @@ test('generates types for after load', async function () {
 	)
 	expect(queryContents).toBeTruthy()
 
+	const parsedQuery = (await parseJS(queryContents!))?.script
+
 	// verify contents
-	expect((await parseJS(queryContents!))?.script).toMatchInlineSnapshot(`
-		import type * as Kit from "@sveltejs/kit";
-		import type { VariableFunction, AfterLoadFunction, BeforeLoadFunction } from "../../../../plugins/houdini-svelte/runtime/types";
-		import type { PageLoadEvent, PageData as KitPageData } from "./$types";
-		import { MyPageLoad1Query$result, MyPageLoad1Query$input } from "../../../../artifacts/MyPageLoad1Query";
-		import { MyPageLoad1QueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageLoad1Query";
-		import { MyPageLoad2Query$result, MyPageLoad2Query$input } from "../../../../artifacts/MyPageLoad2Query";
-		import { MyPageLoad2QueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageLoad2Query";
-		type PageParams = PageLoadEvent["params"];
-		export type MyPageLoad1QueryVariables = VariableFunction<PageParams, MyPageLoad1Query$input>;
-		type AfterLoadReturn = ReturnType<typeof import("./+page").afterLoad>;
-
-		type AfterLoadData = {
-		    MyPageLoad1Query: MyPageLoad1Query$result
-		    MyPageLoad2Query: MyPageLoad2Query$result
-		};
-
-		type LoadInput = {
-		    MyPageLoad1Query: MyPageLoad1Query$input
-		};
-
-		export type AfterLoadEvent = {
-		    event: PageLoadEvent
-		    data: AfterLoadData
-		    input: LoadInput
-		};
-
-		export type PageData = {
-		    MyPageLoad1Query: MyPageLoad1QueryStore
-		    MyPageLoad2Query: MyPageLoad2QueryStore
-		} & AfterLoadReturn;
-	`)
+	expect(parsedQuery).toMatchInlineSnapshot(`import type * as Kit from "@sveltejs/kit";
+import type { AfterLoadFunction } from "../../../../plugins/houdini-svelte/runtime/types";
+import { MyPageLoad1Query$result, MyPageLoad1Query$input } from "../../../../artifacts/MyPageLoad1Query";
+import { MyPageLoad1QueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageLoad1Query";
+import { MyPageLoad2Query$result, MyPageLoad2Query$input } from "../../../../artifacts/MyPageLoad2Query";
+import { MyPageLoad2QueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageLoad2Query";
+
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+
+export type RequiredKeys<T> = {
+    [K in keyof T]?: {} extends {
+        [P in K]: T[K];
+    } ? never : K;
+}[keyof T];
+
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>;
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? {
+    [P in Exclude<A, keyof U>]?: never;
+} & U : never;
+
+type PageParentData = EnsureDefined<import("../$houdini").LayoutData>;
+type PageParams = PageLoadEvent["params"];
+export type PageServerData = null;
+export type PageLoad<OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+
+export type PageData = Expand<Expand<Omit<PageParentData, keyof PageParentData & EnsureDefined<PageServerData>> & OptionalUnion<EnsureDefined<PageParentData & EnsureDefined<PageServerData>>>> & {
+    MyPageLoad1Query: MyPageLoad1QueryStore
+    MyPageLoad2Query: MyPageLoad2QueryStore
+} & AfterLoadReturn>;
+
+type LoadInput = {
+    MyPageLoad1Query: MyPageLoad1Query$input
+};
+
+type AfterLoadReturn = ReturnType<typeof import("./+page").afterLoad>;
+
+type AfterLoadData = {
+    MyPageLoad1Query: MyPageLoad1Query$result
+    MyPageLoad2Query: MyPageLoad2Query$result
+};
+
+export type AfterLoadEvent = {
+    event: PageLoadEvent
+    data: AfterLoadData
+    input: LoadInput
+};
+
+export type MyPageLoad1QueryVariables = VariableFunction<PageParams, MyPageLoad1Query$input>;
+`)
 })
 
 test('generates types for onError', async function () {
@@ -239,6 +439,35 @@ test('generates types for onError', async function () {
 		},
 	})
 
+	await fs.mock({
+		[path.join(config.projectRoot, '.svelte-kit')]: {
+			types: {
+				src: {
+					routes: {
+						myProfile: {
+							'$types.d.ts': `import type * as Kit from '@sveltejs/kit';
+
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+type RouteParams = {  }
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;
+type PageParentData = EnsureDefined<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageLoad<OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Expand<Omit<PageParentData, keyof PageParentData & EnsureDefined<PageServerData>> & OptionalUnion<EnsureDefined<PageParentData & EnsureDefined<PageServerData>>>>;
+`,
+						},
+					},
+				},
+			},
+		},
+	})
+
 	// execute the generator
 	await generate({ config, documents: [], framework: 'kit', plugin_root })
 
@@ -248,29 +477,58 @@ test('generates types for onError', async function () {
 	)
 	expect(queryContents).toBeTruthy()
 
+	const parsedQuery = (await parseJS(queryContents!))?.script
+
 	// verify contents
-	expect((await parseJS(queryContents!))?.script).toMatchInlineSnapshot(`
-		import type * as Kit from "@sveltejs/kit";
-		import type { VariableFunction, AfterLoadFunction, BeforeLoadFunction } from "../../../../plugins/houdini-svelte/runtime/types";
-		import type { PageLoadEvent, PageData as KitPageData } from "./$types";
-		import { MyPageLoad1Query$result, MyPageLoad1Query$input } from "../../../../artifacts/MyPageLoad1Query";
-		import { MyPageLoad1QueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageLoad1Query";
-		import { MyPageLoad2Query$result, MyPageLoad2Query$input } from "../../../../artifacts/MyPageLoad2Query";
-		import { MyPageLoad2QueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageLoad2Query";
-		type PageParams = PageLoadEvent["params"];
-		export type MyPageLoad1QueryVariables = VariableFunction<PageParams, MyPageLoad1Query$input>;
-
-		export type OnErrorEvent = {
-		    event: LoadEvent
-		    input: LoadInput
-		    error: Error | Error[]
-		};
-
-		type OnErrorReturn = ReturnType<typeof import("./+page").onError>;
-
-		export type PageData = {
-		    MyPageLoad1Query: MyPageLoad1QueryStore
-		    MyPageLoad2Query: MyPageLoad2QueryStore
-		} & OnErrorReturn;
-	`)
+	expect(parsedQuery).toMatchInlineSnapshot(`import type * as Kit from "@sveltejs/kit";
+import { MyPageLoad1Query$result, MyPageLoad1Query$input } from "../../../../artifacts/MyPageLoad1Query";
+import { MyPageLoad1QueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageLoad1Query";
+import { MyPageLoad2Query$result, MyPageLoad2Query$input } from "../../../../artifacts/MyPageLoad2Query";
+import { MyPageLoad2QueryStore } from "../../../../plugins/houdini-svelte/stores/MyPageLoad2Query";
+
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+
+export type RequiredKeys<T> = {
+    [K in keyof T]?: {} extends {
+        [P in K]: T[K];
+    } ? never : K;
+}[keyof T];
+
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>;
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? {
+    [P in Exclude<A, keyof U>]?: never;
+} & U : never;
+
+type PageParentData = EnsureDefined<import("../$houdini").LayoutData>;
+type PageParams = PageLoadEvent["params"];
+export type PageServerData = null;
+export type PageLoad<OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+
+export type PageData = Expand<Expand<Omit<PageParentData, keyof PageParentData & EnsureDefined<PageServerData>> & OptionalUnion<EnsureDefined<PageParentData & EnsureDefined<PageServerData>>>> & {
+    MyPageLoad1Query: MyPageLoad1QueryStore
+    MyPageLoad2Query: MyPageLoad2QueryStore
+} & OnErrorReturn>;
+
+type LoadInput = {
+    MyPageLoad1Query: MyPageLoad1Query$input
+};
+
+type OnErrorReturn = ReturnType<typeof import("./+page").onError>;
+
+export type OnErrorEvent = {
+    event: Kit.LoadEvent
+    input: LoadInput
+    error: Error | Error[]
+};
+
+export type MyPageLoad1QueryVariables = VariableFunction<PageParams, MyPageLoad1Query$input>;
+`)
 })
diff --git a/packages/houdini-svelte/src/plugin/kit.ts b/packages/houdini-svelte/src/plugin/kit.ts
index 8c21aa83a5..4ec1c4585a 100644
--- a/packages/houdini-svelte/src/plugin/kit.ts
+++ b/packages/houdini-svelte/src/plugin/kit.ts
@@ -5,6 +5,7 @@ import recast from 'recast'
 
 import { HoudiniVitePluginConfig } from '.'
 import { parseSvelte } from './extract'
+import { extract_load_function } from './extractLoadFunction'
 import { SvelteTransformPage } from './transforms/types'
 
 type Identifier = recast.types.namedTypes.Identifier
@@ -117,95 +118,47 @@ export async function walk_routes(
 	visitor: RouteVisitor,
 	dirpath = config.routesDir
 ) {
-	// if we run into any child with a query, we have a route
-	let isRoute = false
-
-	// we need to collect the important values from each special child
-	// for the visitor.route handler
-	let pageScript: string | null = null
-	let layoutScript: string | null = null
-	let routePageQuery: graphql.OperationDefinitionNode | null = null
-	let routeLayoutQuery: graphql.OperationDefinitionNode | null = null
-	const inlineLayoutQueries: graphql.OperationDefinitionNode[] = []
-	const inlineQueries: graphql.OperationDefinitionNode[] = []
-
-	// process the children
+	let pageExports: string[] = []
+	let layoutExports: string[] = []
+	let pageQueries: graphql.OperationDefinitionNode[] = []
+	let layoutQueries: graphql.OperationDefinitionNode[] = []
+
+	//parse all files and push contents into page/layoutExports, page/layoutQueries
 	for (const child of await fs.readdir(dirpath)) {
 		const childPath = path.join(dirpath, child)
 		// if we run into another directory, keep walking down
 		if ((await fs.stat(childPath)).isDirectory()) {
 			await walk_routes(config, framework, visitor, childPath)
+			//ensure that directories are not passed to route func, pass directory and then skip to next file
+			continue
 		}
 
-		// page scripts
-		else if (is_page_script(framework, child)) {
-			isRoute = true
-			pageScript = childPath
-			if (!visitor.pageScript) {
-				continue
-			}
-			await visitor.pageScript(childPath, childPath)
-		}
-
-		// layout scripts
-		else if (is_layout_script(framework, child)) {
-			isRoute = true
-			layoutScript = childPath
-			if (!visitor.layoutScript) {
-				continue
-			}
-			await visitor.layoutScript(childPath, childPath)
-		}
-
-		// page queries
-		else if (child === plugin_config(config).pageQueryFilename) {
-			isRoute = true
-
-			// load the contents
-			const contents = await fs.readFile(childPath)
-			if (!contents) {
-				continue
-			}
-
-			// invoke the visitor
-			try {
-				routePageQuery = config.extractQueryDefinition(graphql.parse(contents))
-			} catch (e) {
-				throw routeQueryError(childPath)
-			}
-
-			if (!visitor.routePageQuery || !routePageQuery) {
-				continue
-			}
-			await visitor.routePageQuery(routePageQuery, childPath)
-		}
-
-		// layout queries
-		else if (child === plugin_config(config).layoutQueryFilename) {
-			isRoute = true
-
-			// load the contents
-			const contents = await fs.readFile(childPath)
-			if (!contents) {
-				continue
-			}
-
-			// invoke the visitor
-			try {
-				routeLayoutQuery = config.extractQueryDefinition(graphql.parse(contents))
-			} catch (e) {
-				throw routeQueryError(childPath)
-			}
-
-			if (!visitor.routeLayoutQuery || !routeLayoutQuery) {
-				continue
-			}
-			await visitor.routeLayoutQuery(routeLayoutQuery, childPath)
-		}
-
-		// inline layout queries
-		else if (is_layout_component(framework, child)) {
-			// load the contents and parse it
+		//maybe turn into switch-case statement?
+		if (is_layout_script(framework, childPath)) {
+			const { houdini_load, exports } = await extract_load_function(config, childPath)
+
+			// mutate with optional layoutQueries. Takes in array of OperationDefinitionNodes
+			await visitor.layoutQueries?.(houdini_load ?? [], childPath)
+			// push all queries to our layoutQueries
+			layoutQueries.push(...(houdini_load ?? []))
+
+			// mutate with optional layoutExports. Takes in array of strings
+			await visitor.layoutExports?.(exports, childPath)
+			// push all exports to our layoutExports
+			layoutExports.push(...exports)
+		} else if (is_page_script(framework, childPath)) {
+			const { houdini_load, exports } = await extract_load_function(config, childPath)
+
+			// mutate with optional pageQueries. Takes in array of OperationDefinitionNodes
+			await visitor.pageQueries?.(houdini_load ?? [], childPath)
+			// push all queries to our pageQueries
+			pageQueries.push(...(houdini_load ?? []))
+
+			// mutate with optional pageExports. Takes in array of strings
+			await visitor.pageExports?.(exports, childPath)
+			// push all exports to our pageExports
+			pageExports.push(...exports)
+		} else if (is_layout_component(framework, childPath)) {
 			const contents = await fs.readFile(childPath)
 			if (!contents) {
 				continue
@@ -215,7 +168,6 @@ export async function walk_routes(
 				continue
 			}
 
-			// look for any graphql tags and invoke the walker's handler
 			await find_graphql(config, parsed.script, {
 				where: (tag) => {
 					try {
@@ -225,18 +177,15 @@ export async function walk_routes(
 					}
 				},
 				tag: async ({ parsedDocument }) => {
-					isRoute = true
-
 					let definition = config.extractQueryDefinition(parsedDocument)
+
+					// mutate with optional inlineLayoutQuery. Takes an OperationDefinitionNode
 					await visitor.inlineLayoutQueries?.(definition, childPath)
-					inlineLayoutQueries.push(definition)
+					// We push this to layoutQueries since it will be the same in the type file anyway
+					layoutQueries.push(definition)
 				},
 			})
-		}
-
-		// inline queries
-		else if (is_component(config, framework, child)) {
-			// load the contents and parse it
+		} else if (is_component(config, framework, child)) {
 			const contents = await fs.readFile(childPath)
 			if (!contents) {
 				continue
@@ -246,7 +195,7 @@ export async function walk_routes(
 				continue
 			}
 
-			// look for any graphql tags and invoke the walker's handler
+			// look for any graphql tags and push into queries.
 			await find_graphql(config, parsed.script, {
 				where: (tag) => {
 					try {
@@ -256,27 +205,85 @@ export async function walk_routes(
 					}
 				},
 				tag: async ({ parsedDocument }) => {
-					isRoute = true
-
 					let definition = config.extractQueryDefinition(parsedDocument)
-					await visitor.inlineQueries?.(definition, childPath)
-					inlineQueries.push(definition)
+					// mutate with optional inlinePageQuery. Takes an OperationDefinitionNode
+					await visitor.inlinePageQueries?.(definition, childPath)
+					// We push this to pageQueries since it will be the same in the type file anyway
+					pageQueries.push(definition)
 				},
 			})
+		} else if (child === plugin_config(config).layoutQueryFilename) {
+			const contents = await fs.readFile(childPath)
+			if (!contents) {
+				continue
+			}
+			//parse content
+			try {
+				const query = config.extractQueryDefinition(graphql.parse(contents))
+				// mutate with optional routeLayoutQuery. Takes an OperationDefinitionNode
+				await visitor.routeLayoutQuery?.(query, childPath)
+				// push to layoutQueries since once again adding to same file anyway
+				layoutQueries.push(query)
+			} catch (e) {
+				throw routeQueryError(childPath)
+			}
+		} else if (child === plugin_config(config).pageQueryFilename) {
+			const contents = await fs.readFile(childPath)
+			if (!contents) {
+				continue
+			}
+
+			try {
+				const query = config.extractQueryDefinition(graphql.parse(contents))
+				// mutate with optional routePageQuery. Takes an OperationDefinitionNode
+				await visitor.routePageQuery?.(query, childPath)
+				// push to pageQueries since once again adding to same file anyway
+				pageQueries.push(query)
+			} catch (e) {
+				throw routeQueryError(childPath)
+			}
+		} else {
+			continue
 		}
 	}
 
-	// if config path is a route, invoke the handler
-	if (visitor.route && isRoute) {
+	// if length of any field is greater than 0, we run our route.
+	// pageExports can be defined where queries aren't
+	// e.g. QueryVariables but uses parent dirs layoutQuery (probably a bad idea)
+	if (
+		visitor.route &&
+		(pageQueries.length > 0 ||
+			layoutQueries.length > 0 ||
+			pageExports.length > 0 ||
+			layoutExports.length > 0)
+	) {
+		//NOTE: Define sveltekitTypeFilePath here so that we ensure route is valid
+
+		const relative_path_regex = /src(.*)/
+
+		// here we define the location of the correspoding sveltekit type file
+		const svelteTypeFilePath = path.join(
+			config.projectRoot,
+			'.svelte-kit',
+			'types',
+			dirpath.match(relative_path_regex)?.[0] ?? '',
+			'$types.d.ts'
+		)
+
+		// if type does not exists we error.
+		if (!fs.existsSync(svelteTypeFilePath)) {
+			throw Error(`SvelteKit types do not exist at route: ${svelteTypeFilePath}`)
+		}
+
+		// only runs once per directory
 		await visitor.route(
 			{
 				dirpath,
-				pageScript,
-				layoutScript,
-				routePageQuery,
-				routeLayoutQuery,
-				inlineLayoutQueries,
-				inlineQueries,
+				svelteTypeFilePath,
+				layoutQueries,
+				pageQueries,
+				layoutExports,
+				pageExports,
 			},
 			dirpath
 		)
@@ -284,20 +291,21 @@ export async function walk_routes(
 }
 
 export type RouteVisitor = {
-	pageScript?: RouteVisitorHandler<string>
-	layoutScript?: RouteVisitorHandler<string>
+	inlinePageQueries?: RouteVisitorHandler<graphql.OperationDefinitionNode>
+	inlineLayoutQueries?: RouteVisitorHandler<graphql.OperationDefinitionNode>
 	routePageQuery?: RouteVisitorHandler<graphql.OperationDefinitionNode>
 	routeLayoutQuery?: RouteVisitorHandler<graphql.OperationDefinitionNode>
-	inlineLayoutQueries?: RouteVisitorHandler<graphql.OperationDefinitionNode>
-	inlineQueries?: RouteVisitorHandler<graphql.OperationDefinitionNode>
+	layoutQueries?: RouteVisitorHandler<graphql.OperationDefinitionNode[]>
+	pageQueries?: RouteVisitorHandler<graphql.OperationDefinitionNode[]>
+	layoutExports?: RouteVisitorHandler<string[]>
+	pageExports?: RouteVisitorHandler<string[]>
 	route?: RouteVisitorHandler<{
 		dirpath: string
-		pageScript: string | null
-		layoutScript: string | null
-		routePageQuery: graphql.OperationDefinitionNode | null
-		routeLayoutQuery: graphql.OperationDefinitionNode | null
-		inlineLayoutQueries: graphql.OperationDefinitionNode[]
-		inlineQueries: graphql.OperationDefinitionNode[]
+		svelteTypeFilePath: string
+		layoutQueries: graphql.OperationDefinitionNode[]
+		pageQueries: graphql.OperationDefinitionNode[]
+		layoutExports: string[]
+		pageExports: string[]
 	}>
 }
 
diff --git a/packages/houdini/src/lib/fs.ts b/packages/houdini/src/lib/fs.ts
index 561b100a3b..8fdf435e33 100644
--- a/packages/houdini/src/lib/fs.ts
+++ b/packages/houdini/src/lib/fs.ts
@@ -7,6 +7,52 @@ import { promisify } from 'util'
 import { houdini_mode } from './constants'
 import * as path from './path'
 
+export function copyFileSync(src: string, dest: string): void | null {
+	if (houdini_mode.is_testing) {
+		try {
+			if (src.includes('build/runtime') || dest.includes('build/runtime')) {
+				fsExtra.copyFileSync(src, dest)
+				return
+			}
+
+			memfs.copyFileSync(src, dest)
+			return
+		} catch (e) {
+			return null
+		}
+	}
+	try {
+		fsExtra.copyFileSync(src, dest)
+		return
+	} catch (e) {}
+
+	return null
+}
+
+export async function copyFile(src: string, dest: string): Promise<void | null> {
+	if (houdini_mode.is_testing) {
+		try {
+			if (src.includes('build/runtime') || dest.includes('build/runtime')) {
+				await fs.copyFile(src, dest)
+				return
+			}
+
+			await memfs.copyFile(src, dest, (err) => {
+				throw err
+			})
+			return
+		} catch (e) {
+			return null
+		}
+	}
+	try {
+		await fs.copyFile(src, dest)
+		return
+	} catch (e) {}
+
+	return null
+}
+
 export async function readFile(filepath: string): Promise<string | null> {
 	if (houdini_mode.is_testing) {
 		try {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e1b47b8f82..10e4f02c13 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1,4 +1,4 @@
-lockfileVersion: 5.4
+lockfileVersion: 5.4 
 
 importers:
     .: