houdini-svelte 0.17.11 → 0.17.13

package/build/plugin-cjs/index.js

@@ -179846,6 +179846,24 @@ async function svelteKitGenerator(framework2, { config: config2 }) {
           config2,
           uniquePageQueries
         );
+        const layout_append_beforeLoad = append_beforeLoad(beforeLayoutLoad, "Layout");
+        const page_append_beforeLoad = append_beforeLoad(beforePageLoad, "Page");
+        const layout_append_afterLoad = append_afterLoad(
+          afterLayoutLoad,
+          "Layout",
+          layoutQueries
+        );
+        const page_append_afterLoad = append_afterLoad(afterPageLoad, "Page", pageQueries);
+        const layout_append_onError = append_onError(
+          onLayoutError,
+          "Layout",
+          layoutQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
+        );
+        const page_append_onError = append_onError(
+          onPageError,
+          "Page",
+          pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
+        );
         const splitString = skTypeString.split("\n\n");
         let typeImports = splitString[0];
         let utilityTypes = splitString[1];
@@ -179868,17 +179886,7 @@ import type { ${functionImportsToBring.join(
         const layoutParams = `${layoutQueries.length > 0 && !utilityTypes.includes("LayoutParams") ? "\ntype LayoutParams = LayoutLoadEvent['params'];" : ""}`;
         const pageParams = `${pageQueries.length > 0 && !utilityTypes.includes("PageParams") ? "\ntype PageParams = PageLoadEvent['params'];" : ""}`;
         utilityTypes = utilityTypes.concat(layoutParams).concat(pageParams).replaceAll(/\$types\.js/gm, "$houdini");
-        typeExports = typeExports.concat(append_loadInput(layoutQueries)).concat(append_loadInput(pageQueries)).concat(append_beforeLoad(beforeLayoutLoad)).concat(append_beforeLoad(beforePageLoad)).concat(append_afterLoad("Layout", afterLayoutLoad, layoutQueries)).concat(append_afterLoad("Page", afterPageLoad, pageQueries)).concat(
-          append_onError(
-            onPageError,
-            pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
-          )
-        ).concat(
-          append_onError(
-            onLayoutError,
-            pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
-          )
-        ).concat(layout_append_VariablesFunction).concat(page_append_VariablesFunction).replace(
+        typeExports = typeExports.concat(append_loadInput(layoutQueries)).concat(append_loadInput(pageQueries)).concat(layout_append_beforeLoad).concat(page_append_beforeLoad).concat(layout_append_afterLoad).concat(page_append_afterLoad).concat(layout_append_onError).concat(page_append_onError).concat(layout_append_VariablesFunction).concat(page_append_VariablesFunction).replace(
           /(?<=LayoutData = )([\s\S]*?)(?=;)/,
           `Expand<$1 & { ${layoutQueries.map((query) => {
             const name2 = query.name.value;
@@ -179942,15 +179950,15 @@ type LoadInput = { ${queries.filter((query) => query.variableDefinitions?.length
     return [name2, name2 + "$input"].join(": ");
   }).join("; ")} };` : ""}`;
 }
-function append_afterLoad(type, afterLoad, queries) {
+function append_afterLoad(afterLoad, type, queries) {
   return afterLoad ? `
-type AfterLoadReturn = ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>;
+type AfterLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>>;
 type AfterLoadData = {
 	${internal_append_afterLoad(queries)}
 };
 
 export type AfterLoadEvent = {
-	event: PageLoadEvent
+	event: ${type}LoadEvent
 	data: AfterLoadData
 	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? "LoadInput" : "{}"}
 };
@@ -179962,15 +179970,15 @@ function internal_append_afterLoad(queries) {
     return [name2, name2 + "$result"].join(": ");
   }).join(";\n	")}`;
 }
-function append_beforeLoad(beforeLoad) {
+function append_beforeLoad(beforeLoad, type) {
   return beforeLoad ? `
-export type BeforeLoadEvent = PageLoadEvent;
-type BeforeLoadReturn = ReturnType<typeof import('./+page').beforeLoad>;
+export type BeforeLoadEvent = ${type}LoadEvent;
+type BeforeLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').beforeLoad>>;
 ` : "";
 }
-function append_onError(onError, hasLoadInput) {
+function append_onError(onError, type, hasLoadInput) {
   return onError ? `
-type OnErrorReturn = ReturnType<typeof import('./+page').onError>;
+type OnErrorReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').onError>>;
 export type OnErrorEvent =  { event: Kit.LoadEvent, input: ${hasLoadInput ? "LoadInput" : "{}"}, error: Error | Error[] };
 ` : "";
 }
@@ -180119,8 +180127,6 @@ async function queryStore({ config: config2, plugin_root }, doc) {
   const storeData = `${statement}
 import artifact from '$houdini/artifacts/${artifactName}'
 
-// create the query store
-
 export class ${storeName} extends ${store_class} {
 	constructor() {
 		super({
@@ -180150,16 +180156,78 @@ export default ${globalStoreName}
   const typeDefs = `import type { ${_input}, ${_data}, ${store_class}, QueryStoreFetchParams} from '$houdini'
 
 export declare class ${storeName} extends ${store_class}<${_data}, ${_input}> {
+	/**
+	 * ### Route Loads
+	 * In a route's load function, manually instantiating a store can be used to look at the result:
+	 * 
+	 * \`\`\`js
+	 * export async function load(event) {
+	 * 	const store = new ${storeName}Store()
+	 * 	const { data } = await store.fetch({event})
+	 *  console.log('do something with', data)
+	 * 
+	 * 	return { 
+	 * 		${storeName}: store,
+	 * 	}
+	 * }
+	 * 
+	 * \`\`\`
+	 * 
+	 * ### Client Side Loading
+	 * When performing a client-side only fetch, the best practice to use a store _manually_ is to do the following:
+	 * 
+	 * \`\`\`js
+	 * const store = new ${storeName}Store()
+	 * 
+	 * $: browser && store.fetch({ variables });
+	 * \`\`\`
+	 */
 	constructor() {
 		// @ts-ignore
 		super({})
 	}
 }
 
-export const ${globalStoreName}: ${storeName}
-
+/**
+ * ### Manual Loads
+ * Usually your load function will look like this:
+ * 
+ * \`\`\`js
+ * import { load_${artifactName} } from '$houdini';
+ * import type { PageLoad } from './$types';
+ * 
+ * export const load: PageLoad = async (event) => {
+ *   const variables = {
+ *     id: // Something like: event.url.searchParams.get('id')
+ *   };
+ * 
+ *   return await load_${artifactName}({ event, variables });
+ * }; 
+ * \`\`\`
+ * 
+ * ### Multiple stores to load
+ * You can trigger them in parallel with \`loadAll\` function
+ * 
+ * \`\`\`js
+ * import { loadAll, load_${artifactName} } from '$houdini';
+ * import type { PageLoad } from './$types';
+ * 
+ * export const load: PageLoad = async (event) => {
+ *   const variables = {
+ *     id: // Something like: event.url.searchParams.get('id')
+ *   };
+ * 
+ *   return await await loadAll(
+ *     load_${artifactName}({ event, variables }),
+ *     // load_ANOTHER_STORE
+ *   );
+ * }; 
+ * \`\`\`
+ */
 export declare const load_${artifactName}: (params: QueryStoreFetchParams<${_data}, ${_input}>) => Promise<{${artifactName}: ${storeName}}>
 
+export const ${globalStoreName}: ${storeName}
+
 export default ${storeName}
 `;
   await Promise.all([

package/build/plugin-esm/index.js

@@ -179842,6 +179842,24 @@ async function svelteKitGenerator(framework2, { config: config2 }) {
           config2,
           uniquePageQueries
         );
+        const layout_append_beforeLoad = append_beforeLoad(beforeLayoutLoad, "Layout");
+        const page_append_beforeLoad = append_beforeLoad(beforePageLoad, "Page");
+        const layout_append_afterLoad = append_afterLoad(
+          afterLayoutLoad,
+          "Layout",
+          layoutQueries
+        );
+        const page_append_afterLoad = append_afterLoad(afterPageLoad, "Page", pageQueries);
+        const layout_append_onError = append_onError(
+          onLayoutError,
+          "Layout",
+          layoutQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
+        );
+        const page_append_onError = append_onError(
+          onPageError,
+          "Page",
+          pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
+        );
         const splitString = skTypeString.split("\n\n");
         let typeImports = splitString[0];
         let utilityTypes = splitString[1];
@@ -179864,17 +179882,7 @@ import type { ${functionImportsToBring.join(
         const layoutParams = `${layoutQueries.length > 0 && !utilityTypes.includes("LayoutParams") ? "\ntype LayoutParams = LayoutLoadEvent['params'];" : ""}`;
         const pageParams = `${pageQueries.length > 0 && !utilityTypes.includes("PageParams") ? "\ntype PageParams = PageLoadEvent['params'];" : ""}`;
         utilityTypes = utilityTypes.concat(layoutParams).concat(pageParams).replaceAll(/\$types\.js/gm, "$houdini");
-        typeExports = typeExports.concat(append_loadInput(layoutQueries)).concat(append_loadInput(pageQueries)).concat(append_beforeLoad(beforeLayoutLoad)).concat(append_beforeLoad(beforePageLoad)).concat(append_afterLoad("Layout", afterLayoutLoad, layoutQueries)).concat(append_afterLoad("Page", afterPageLoad, pageQueries)).concat(
-          append_onError(
-            onPageError,
-            pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
-          )
-        ).concat(
-          append_onError(
-            onLayoutError,
-            pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
-          )
-        ).concat(layout_append_VariablesFunction).concat(page_append_VariablesFunction).replace(
+        typeExports = typeExports.concat(append_loadInput(layoutQueries)).concat(append_loadInput(pageQueries)).concat(layout_append_beforeLoad).concat(page_append_beforeLoad).concat(layout_append_afterLoad).concat(page_append_afterLoad).concat(layout_append_onError).concat(page_append_onError).concat(layout_append_VariablesFunction).concat(page_append_VariablesFunction).replace(
           /(?<=LayoutData = )([\s\S]*?)(?=;)/,
           `Expand<$1 & { ${layoutQueries.map((query) => {
             const name2 = query.name.value;
@@ -179938,15 +179946,15 @@ type LoadInput = { ${queries.filter((query) => query.variableDefinitions?.length
     return [name2, name2 + "$input"].join(": ");
   }).join("; ")} };` : ""}`;
 }
-function append_afterLoad(type, afterLoad, queries) {
+function append_afterLoad(afterLoad, type, queries) {
   return afterLoad ? `
-type AfterLoadReturn = ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>;
+type AfterLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>>;
 type AfterLoadData = {
 	${internal_append_afterLoad(queries)}
 };
 
 export type AfterLoadEvent = {
-	event: PageLoadEvent
+	event: ${type}LoadEvent
 	data: AfterLoadData
 	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? "LoadInput" : "{}"}
 };
@@ -179958,15 +179966,15 @@ function internal_append_afterLoad(queries) {
     return [name2, name2 + "$result"].join(": ");
   }).join(";\n	")}`;
 }
-function append_beforeLoad(beforeLoad) {
+function append_beforeLoad(beforeLoad, type) {
   return beforeLoad ? `
-export type BeforeLoadEvent = PageLoadEvent;
-type BeforeLoadReturn = ReturnType<typeof import('./+page').beforeLoad>;
+export type BeforeLoadEvent = ${type}LoadEvent;
+type BeforeLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').beforeLoad>>;
 ` : "";
 }
-function append_onError(onError, hasLoadInput) {
+function append_onError(onError, type, hasLoadInput) {
   return onError ? `
-type OnErrorReturn = ReturnType<typeof import('./+page').onError>;
+type OnErrorReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').onError>>;
 export type OnErrorEvent =  { event: Kit.LoadEvent, input: ${hasLoadInput ? "LoadInput" : "{}"}, error: Error | Error[] };
 ` : "";
 }
@@ -180115,8 +180123,6 @@ async function queryStore({ config: config2, plugin_root }, doc) {
   const storeData = `${statement}
 import artifact from '$houdini/artifacts/${artifactName}'
 
-// create the query store
-
 export class ${storeName} extends ${store_class} {
 	constructor() {
 		super({
@@ -180146,16 +180152,78 @@ export default ${globalStoreName}
   const typeDefs = `import type { ${_input}, ${_data}, ${store_class}, QueryStoreFetchParams} from '$houdini'
 
 export declare class ${storeName} extends ${store_class}<${_data}, ${_input}> {
+	/**
+	 * ### Route Loads
+	 * In a route's load function, manually instantiating a store can be used to look at the result:
+	 * 
+	 * \`\`\`js
+	 * export async function load(event) {
+	 * 	const store = new ${storeName}Store()
+	 * 	const { data } = await store.fetch({event})
+	 *  console.log('do something with', data)
+	 * 
+	 * 	return { 
+	 * 		${storeName}: store,
+	 * 	}
+	 * }
+	 * 
+	 * \`\`\`
+	 * 
+	 * ### Client Side Loading
+	 * When performing a client-side only fetch, the best practice to use a store _manually_ is to do the following:
+	 * 
+	 * \`\`\`js
+	 * const store = new ${storeName}Store()
+	 * 
+	 * $: browser && store.fetch({ variables });
+	 * \`\`\`
+	 */
 	constructor() {
 		// @ts-ignore
 		super({})
 	}
 }
 
-export const ${globalStoreName}: ${storeName}
-
+/**
+ * ### Manual Loads
+ * Usually your load function will look like this:
+ * 
+ * \`\`\`js
+ * import { load_${artifactName} } from '$houdini';
+ * import type { PageLoad } from './$types';
+ * 
+ * export const load: PageLoad = async (event) => {
+ *   const variables = {
+ *     id: // Something like: event.url.searchParams.get('id')
+ *   };
+ * 
+ *   return await load_${artifactName}({ event, variables });
+ * }; 
+ * \`\`\`
+ * 
+ * ### Multiple stores to load
+ * You can trigger them in parallel with \`loadAll\` function
+ * 
+ * \`\`\`js
+ * import { loadAll, load_${artifactName} } from '$houdini';
+ * import type { PageLoad } from './$types';
+ * 
+ * export const load: PageLoad = async (event) => {
+ *   const variables = {
+ *     id: // Something like: event.url.searchParams.get('id')
+ *   };
+ * 
+ *   return await await loadAll(
+ *     load_${artifactName}({ event, variables }),
+ *     // load_ANOTHER_STORE
+ *   );
+ * }; 
+ * \`\`\`
+ */
 export declare const load_${artifactName}: (params: QueryStoreFetchParams<${_data}, ${_input}>) => Promise<{${artifactName}: ${storeName}}>
 
+export const ${globalStoreName}: ${storeName}
+
 export default ${storeName}
 `;
   await Promise.all([

package/build/runtime/stores/pagination/query.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLObject, QueryArtifact, QueryResult } from '$houdini/runtime/lib/types';
 import { Subscriber } from 'svelte/store';
-import { QueryStore, StoreConfig, LoadEventFetchParams, RequestEventFetchParams, QueryStoreFetchParams, ClientFetchParams } from '../query';
+import { ClientFetchParams, LoadEventFetchParams, QueryStore, QueryStoreFetchParams, RequestEventFetchParams, StoreConfig } from '../query';
 import { CursorHandlers } from './cursor';
 import { OffsetHandlers } from './offset';
 import { PageInfo } from './pageInfo';

package/build/runtime/stores/query.d.ts

@@ -1,7 +1,6 @@
 import { FetchContext } from '$houdini/runtime/lib/network';
 import type { QueryArtifact } from '$houdini/runtime/lib/types';
-import { CachePolicy, GraphQLObject, QueryResult } from '$houdini/runtime/lib/types';
-import { SubscriptionSpec, HoudiniFetchContext } from '$houdini/runtime/lib/types';
+import { CachePolicy, GraphQLObject, HoudiniFetchContext, QueryResult, SubscriptionSpec } from '$houdini/runtime/lib/types';
 import type { LoadEvent, RequestEvent } from '@sveltejs/kit';
 import { Readable, Writable } from 'svelte/store';
 import { BaseStore } from './store';

package/build/runtime-cjs/stores/pagination/query.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLObject, QueryArtifact, QueryResult } from '$houdini/runtime/lib/types';
 import { Subscriber } from 'svelte/store';
-import { QueryStore, StoreConfig, LoadEventFetchParams, RequestEventFetchParams, QueryStoreFetchParams, ClientFetchParams } from '../query';
+import { ClientFetchParams, LoadEventFetchParams, QueryStore, QueryStoreFetchParams, RequestEventFetchParams, StoreConfig } from '../query';
 import { CursorHandlers } from './cursor';
 import { OffsetHandlers } from './offset';
 import { PageInfo } from './pageInfo';

package/build/runtime-cjs/stores/query.d.ts

@@ -1,7 +1,6 @@
 import { FetchContext } from '$houdini/runtime/lib/network';
 import type { QueryArtifact } from '$houdini/runtime/lib/types';
-import { CachePolicy, GraphQLObject, QueryResult } from '$houdini/runtime/lib/types';
-import { SubscriptionSpec, HoudiniFetchContext } from '$houdini/runtime/lib/types';
+import { CachePolicy, GraphQLObject, HoudiniFetchContext, QueryResult, SubscriptionSpec } from '$houdini/runtime/lib/types';
 import type { LoadEvent, RequestEvent } from '@sveltejs/kit';
 import { Readable, Writable } from 'svelte/store';
 import { BaseStore } from './store';

package/build/runtime-cjs/stores/query.js

@@ -34,16 +34,15 @@ var log = __toESM(require("$houdini/runtime/lib/log"), 1);
 var import_network = require("$houdini/runtime/lib/network");
 var import_scalars = require("$houdini/runtime/lib/scalars");
 var import_types = require("$houdini/runtime/lib/types");
-var import_types2 = require("$houdini/runtime/lib/types");
 var import_store = require("svelte/store");
 var import_adapter = require("../adapter");
-var import_network3 = require("../network");
+var import_network2 = require("../network");
 var import_session = require("../session");
 var import_store2 = require("./store");
 class QueryStore extends import_store2.BaseStore {
   artifact;
   variables;
-  kind = import_types2.CompiledQueryKind;
+  kind = import_types.CompiledQueryKind;
   store;
   lastVariables = null;
   subscriptionSpec = null;
@@ -83,9 +82,7 @@ class QueryStore extends import_store2.BaseStore {
     }
     if (this.loadPending && isComponentFetch) {
       log.error(`\u26A0\uFE0F Encountered fetch from your component while ${this.storeName}.load was running.
-This will result in duplicate queries. If you are trying to ensure there is always a good value, please a CachePolicy instead.
-If this is leftovers from old versions of houdini, you can safely remove this \`${this.storeName}\`.fetch() from your component.
-`);
+This will result in duplicate queries. If you are trying to ensure there is always a good value, please a CachePolicy instead.`);
       return (0, import_store.get)(this.store);
     }
     if (isComponentFetch) {
@@ -94,8 +91,7 @@ If this is leftovers from old versions of houdini, you can safely remove this \`
     if (isLoadFetch) {
       this.loadPending = true;
     }
-    const fakeAwait = import_adapter.clientStarted && import_adapter.isBrowser && !params?.blocking;
-    const request = this.fetchAndCache({
+    const fetchArgs = {
       config,
       context,
       artifact: this.artifact,
@@ -106,7 +102,22 @@ If this is leftovers from old versions of houdini, you can safely remove this \`
         this.loadPending = val;
         this.setFetching(val);
       }
-    });
+    };
+    const fakeAwait = import_adapter.clientStarted && import_adapter.isBrowser && !params?.blocking;
+    if (policy !== import_types.CachePolicy.NetworkOnly && fakeAwait) {
+      const cachedStore = await this.fetchAndCache({
+        ...fetchArgs,
+        rawCacheOnlyResult: true
+      });
+      if (cachedStore && cachedStore?.result.data) {
+        this.store.update((s) => ({
+          ...s,
+          data: cachedStore?.result.data,
+          isFetching: false
+        }));
+      }
+    }
+    const request = this.fetchAndCache(fetchArgs);
     if (params.then) {
       request.then((val) => params.then?.(val.result.data));
     }
@@ -144,19 +155,23 @@ If this is leftovers from old versions of houdini, you can safely remove this \`
     ignoreFollowup,
     setLoadPending,
     policy,
-    context
+    context,
+    rawCacheOnlyResult = false
   }) {
     const request = await (0, import_network.fetchQuery)({
       ...context,
-      client: await (0, import_network3.getCurrentClient)(),
+      client: await (0, import_network2.getCurrentClient)(),
       setFetching: (val) => this.setFetching(val),
       artifact,
       variables,
       cached,
-      policy,
+      policy: rawCacheOnlyResult ? import_types.CachePolicy.CacheOnly : policy,
       context
     });
     const { result, source, partial } = request;
+    if (rawCacheOnlyResult) {
+      return request;
+    }
     setLoadPending(false);
     if (result.data && source !== import_types.DataSource.Cache) {
       (0, import_runtime.getCache)().write({

package/build/runtime-esm/stores/pagination/query.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLObject, QueryArtifact, QueryResult } from '$houdini/runtime/lib/types';
 import { Subscriber } from 'svelte/store';
-import { QueryStore, StoreConfig, LoadEventFetchParams, RequestEventFetchParams, QueryStoreFetchParams, ClientFetchParams } from '../query';
+import { ClientFetchParams, LoadEventFetchParams, QueryStore, QueryStoreFetchParams, RequestEventFetchParams, StoreConfig } from '../query';
 import { CursorHandlers } from './cursor';
 import { OffsetHandlers } from './offset';
 import { PageInfo } from './pageInfo';

package/build/runtime-esm/stores/query.d.ts

@@ -1,7 +1,6 @@
 import { FetchContext } from '$houdini/runtime/lib/network';
 import type { QueryArtifact } from '$houdini/runtime/lib/types';
-import { CachePolicy, GraphQLObject, QueryResult } from '$houdini/runtime/lib/types';
-import { SubscriptionSpec, HoudiniFetchContext } from '$houdini/runtime/lib/types';
+import { CachePolicy, GraphQLObject, HoudiniFetchContext, QueryResult, SubscriptionSpec } from '$houdini/runtime/lib/types';
 import type { LoadEvent, RequestEvent } from '@sveltejs/kit';
 import { Readable, Writable } from 'svelte/store';
 import { BaseStore } from './store';

package/build/runtime-esm/stores/query.js

@@ -3,12 +3,13 @@ import { deepEquals } from "$houdini/runtime/lib/deepEquals";
 import * as log from "$houdini/runtime/lib/log";
 import { fetchQuery } from "$houdini/runtime/lib/network";
 import { marshalInputs, unmarshalSelection } from "$houdini/runtime/lib/scalars";
-import { CachePolicy, DataSource } from "$houdini/runtime/lib/types";
 import {
-  CompiledQueryKind
+  CachePolicy,
+  CompiledQueryKind,
+  DataSource
 } from "$houdini/runtime/lib/types";
 import { get, writable } from "svelte/store";
-import { clientStarted, isBrowser, error } from "../adapter";
+import { clientStarted, error, isBrowser } from "../adapter";
 import { getCurrentClient } from "../network";
 import { getSession } from "../session";
 import { BaseStore } from "./store";
@@ -55,9 +56,7 @@ class QueryStore extends BaseStore {
     }
     if (this.loadPending && isComponentFetch) {
       log.error(`\u26A0\uFE0F Encountered fetch from your component while ${this.storeName}.load was running.
-This will result in duplicate queries. If you are trying to ensure there is always a good value, please a CachePolicy instead.
-If this is leftovers from old versions of houdini, you can safely remove this \`${this.storeName}\`.fetch() from your component.
-`);
+This will result in duplicate queries. If you are trying to ensure there is always a good value, please a CachePolicy instead.`);
       return get(this.store);
     }
     if (isComponentFetch) {
@@ -66,8 +65,7 @@ If this is leftovers from old versions of houdini, you can safely remove this \`
     if (isLoadFetch) {
       this.loadPending = true;
     }
-    const fakeAwait = clientStarted && isBrowser && !params?.blocking;
-    const request = this.fetchAndCache({
+    const fetchArgs = {
       config,
       context,
       artifact: this.artifact,
@@ -78,7 +76,22 @@ If this is leftovers from old versions of houdini, you can safely remove this \`
         this.loadPending = val;
         this.setFetching(val);
       }
-    });
+    };
+    const fakeAwait = clientStarted && isBrowser && !params?.blocking;
+    if (policy !== CachePolicy.NetworkOnly && fakeAwait) {
+      const cachedStore = await this.fetchAndCache({
+        ...fetchArgs,
+        rawCacheOnlyResult: true
+      });
+      if (cachedStore && cachedStore?.result.data) {
+        this.store.update((s) => ({
+          ...s,
+          data: cachedStore?.result.data,
+          isFetching: false
+        }));
+      }
+    }
+    const request = this.fetchAndCache(fetchArgs);
     if (params.then) {
       request.then((val) => params.then?.(val.result.data));
     }
@@ -116,7 +129,8 @@ If this is leftovers from old versions of houdini, you can safely remove this \`
     ignoreFollowup,
     setLoadPending,
     policy,
-    context
+    context,
+    rawCacheOnlyResult = false
   }) {
     const request = await fetchQuery({
       ...context,
@@ -125,10 +139,13 @@ If this is leftovers from old versions of houdini, you can safely remove this \`
       artifact,
       variables,
       cached,
-      policy,
+      policy: rawCacheOnlyResult ? CachePolicy.CacheOnly : policy,
       context
     });
     const { result, source, partial } = request;
+    if (rawCacheOnlyResult) {
+      return request;
+    }
     setLoadPending(false);
     if (result.data && source !== DataSource.Cache) {
       getCache().write({

package/build/test-cjs/index.js

@@ -294501,6 +294501,24 @@ async function svelteKitGenerator(framework2, { config: config3 }) {
           config3,
           uniquePageQueries
         );
+        const layout_append_beforeLoad = append_beforeLoad(beforeLayoutLoad, "Layout");
+        const page_append_beforeLoad = append_beforeLoad(beforePageLoad, "Page");
+        const layout_append_afterLoad = append_afterLoad(
+          afterLayoutLoad,
+          "Layout",
+          layoutQueries
+        );
+        const page_append_afterLoad = append_afterLoad(afterPageLoad, "Page", pageQueries);
+        const layout_append_onError = append_onError(
+          onLayoutError,
+          "Layout",
+          layoutQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
+        );
+        const page_append_onError = append_onError(
+          onPageError,
+          "Page",
+          pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
+        );
         const splitString = skTypeString.split("\n\n");
         let typeImports = splitString[0];
         let utilityTypes = splitString[1];
@@ -294523,17 +294541,7 @@ import type { ${functionImportsToBring.join(
         const layoutParams = `${layoutQueries.length > 0 && !utilityTypes.includes("LayoutParams") ? "\ntype LayoutParams = LayoutLoadEvent['params'];" : ""}`;
         const pageParams = `${pageQueries.length > 0 && !utilityTypes.includes("PageParams") ? "\ntype PageParams = PageLoadEvent['params'];" : ""}`;
         utilityTypes = utilityTypes.concat(layoutParams).concat(pageParams).replaceAll(/\$types\.js/gm, "$houdini");
-        typeExports = typeExports.concat(append_loadInput(layoutQueries)).concat(append_loadInput(pageQueries)).concat(append_beforeLoad(beforeLayoutLoad)).concat(append_beforeLoad(beforePageLoad)).concat(append_afterLoad("Layout", afterLayoutLoad, layoutQueries)).concat(append_afterLoad("Page", afterPageLoad, pageQueries)).concat(
-          append_onError(
-            onPageError,
-            pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
-          )
-        ).concat(
-          append_onError(
-            onLayoutError,
-            pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
-          )
-        ).concat(layout_append_VariablesFunction).concat(page_append_VariablesFunction).replace(
+        typeExports = typeExports.concat(append_loadInput(layoutQueries)).concat(append_loadInput(pageQueries)).concat(layout_append_beforeLoad).concat(page_append_beforeLoad).concat(layout_append_afterLoad).concat(page_append_afterLoad).concat(layout_append_onError).concat(page_append_onError).concat(layout_append_VariablesFunction).concat(page_append_VariablesFunction).replace(
           /(?<=LayoutData = )([\s\S]*?)(?=;)/,
           `Expand<$1 & { ${layoutQueries.map((query) => {
             const name2 = query.name.value;
@@ -294597,15 +294605,15 @@ type LoadInput = { ${queries.filter((query) => query.variableDefinitions?.length
     return [name2, name2 + "$input"].join(": ");
   }).join("; ")} };` : ""}`;
 }
-function append_afterLoad(type, afterLoad, queries) {
+function append_afterLoad(afterLoad, type, queries) {
   return afterLoad ? `
-type AfterLoadReturn = ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>;
+type AfterLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>>;
 type AfterLoadData = {
 	${internal_append_afterLoad(queries)}
 };
 
 export type AfterLoadEvent = {
-	event: PageLoadEvent
+	event: ${type}LoadEvent
 	data: AfterLoadData
 	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? "LoadInput" : "{}"}
 };
@@ -294617,15 +294625,15 @@ function internal_append_afterLoad(queries) {
     return [name2, name2 + "$result"].join(": ");
   }).join(";\n	")}`;
 }
-function append_beforeLoad(beforeLoad) {
+function append_beforeLoad(beforeLoad, type) {
   return beforeLoad ? `
-export type BeforeLoadEvent = PageLoadEvent;
-type BeforeLoadReturn = ReturnType<typeof import('./+page').beforeLoad>;
+export type BeforeLoadEvent = ${type}LoadEvent;
+type BeforeLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').beforeLoad>>;
 ` : "";
 }
-function append_onError(onError, hasLoadInput) {
+function append_onError(onError, type, hasLoadInput) {
   return onError ? `
-type OnErrorReturn = ReturnType<typeof import('./+page').onError>;
+type OnErrorReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').onError>>;
 export type OnErrorEvent =  { event: Kit.LoadEvent, input: ${hasLoadInput ? "LoadInput" : "{}"}, error: Error | Error[] };
 ` : "";
 }
@@ -294774,8 +294782,6 @@ async function queryStore({ config: config3, plugin_root }, doc) {
   const storeData = `${statement}
 import artifact from '$houdini/artifacts/${artifactName}'
 
-// create the query store
-
 export class ${storeName} extends ${store_class} {
 	constructor() {
 		super({
@@ -294805,16 +294811,78 @@ export default ${globalStoreName}
   const typeDefs = `import type { ${_input}, ${_data}, ${store_class}, QueryStoreFetchParams} from '$houdini'
 
 export declare class ${storeName} extends ${store_class}<${_data}, ${_input}> {
+	/**
+	 * ### Route Loads
+	 * In a route's load function, manually instantiating a store can be used to look at the result:
+	 * 
+	 * \`\`\`js
+	 * export async function load(event) {
+	 * 	const store = new ${storeName}Store()
+	 * 	const { data } = await store.fetch({event})
+	 *  console.log('do something with', data)
+	 * 
+	 * 	return { 
+	 * 		${storeName}: store,
+	 * 	}
+	 * }
+	 * 
+	 * \`\`\`
+	 * 
+	 * ### Client Side Loading
+	 * When performing a client-side only fetch, the best practice to use a store _manually_ is to do the following:
+	 * 
+	 * \`\`\`js
+	 * const store = new ${storeName}Store()
+	 * 
+	 * $: browser && store.fetch({ variables });
+	 * \`\`\`
+	 */
 	constructor() {
 		// @ts-ignore
 		super({})
 	}
 }
 
-export const ${globalStoreName}: ${storeName}
-
+/**
+ * ### Manual Loads
+ * Usually your load function will look like this:
+ * 
+ * \`\`\`js
+ * import { load_${artifactName} } from '$houdini';
+ * import type { PageLoad } from './$types';
+ * 
+ * export const load: PageLoad = async (event) => {
+ *   const variables = {
+ *     id: // Something like: event.url.searchParams.get('id')
+ *   };
+ * 
+ *   return await load_${artifactName}({ event, variables });
+ * }; 
+ * \`\`\`
+ * 
+ * ### Multiple stores to load
+ * You can trigger them in parallel with \`loadAll\` function
+ * 
+ * \`\`\`js
+ * import { loadAll, load_${artifactName} } from '$houdini';
+ * import type { PageLoad } from './$types';
+ * 
+ * export const load: PageLoad = async (event) => {
+ *   const variables = {
+ *     id: // Something like: event.url.searchParams.get('id')
+ *   };
+ * 
+ *   return await await loadAll(
+ *     load_${artifactName}({ event, variables }),
+ *     // load_ANOTHER_STORE
+ *   );
+ * }; 
+ * \`\`\`
+ */
 export declare const load_${artifactName}: (params: QueryStoreFetchParams<${_data}, ${_input}>) => Promise<{${artifactName}: ${storeName}}>
 
+export const ${globalStoreName}: ${storeName}
+
 export default ${storeName}
 `;
   await Promise.all([

package/build/test-esm/index.js

@@ -294490,6 +294490,24 @@ async function svelteKitGenerator(framework2, { config: config3 }) {
           config3,
           uniquePageQueries
         );
+        const layout_append_beforeLoad = append_beforeLoad(beforeLayoutLoad, "Layout");
+        const page_append_beforeLoad = append_beforeLoad(beforePageLoad, "Page");
+        const layout_append_afterLoad = append_afterLoad(
+          afterLayoutLoad,
+          "Layout",
+          layoutQueries
+        );
+        const page_append_afterLoad = append_afterLoad(afterPageLoad, "Page", pageQueries);
+        const layout_append_onError = append_onError(
+          onLayoutError,
+          "Layout",
+          layoutQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
+        );
+        const page_append_onError = append_onError(
+          onPageError,
+          "Page",
+          pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
+        );
         const splitString = skTypeString.split("\n\n");
         let typeImports = splitString[0];
         let utilityTypes = splitString[1];
@@ -294512,17 +294530,7 @@ import type { ${functionImportsToBring.join(
         const layoutParams = `${layoutQueries.length > 0 && !utilityTypes.includes("LayoutParams") ? "\ntype LayoutParams = LayoutLoadEvent['params'];" : ""}`;
         const pageParams = `${pageQueries.length > 0 && !utilityTypes.includes("PageParams") ? "\ntype PageParams = PageLoadEvent['params'];" : ""}`;
         utilityTypes = utilityTypes.concat(layoutParams).concat(pageParams).replaceAll(/\$types\.js/gm, "$houdini");
-        typeExports = typeExports.concat(append_loadInput(layoutQueries)).concat(append_loadInput(pageQueries)).concat(append_beforeLoad(beforeLayoutLoad)).concat(append_beforeLoad(beforePageLoad)).concat(append_afterLoad("Layout", afterLayoutLoad, layoutQueries)).concat(append_afterLoad("Page", afterPageLoad, pageQueries)).concat(
-          append_onError(
-            onPageError,
-            pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
-          )
-        ).concat(
-          append_onError(
-            onLayoutError,
-            pageQueries.filter((x4) => x4.variableDefinitions?.length).length > 0
-          )
-        ).concat(layout_append_VariablesFunction).concat(page_append_VariablesFunction).replace(
+        typeExports = typeExports.concat(append_loadInput(layoutQueries)).concat(append_loadInput(pageQueries)).concat(layout_append_beforeLoad).concat(page_append_beforeLoad).concat(layout_append_afterLoad).concat(page_append_afterLoad).concat(layout_append_onError).concat(page_append_onError).concat(layout_append_VariablesFunction).concat(page_append_VariablesFunction).replace(
           /(?<=LayoutData = )([\s\S]*?)(?=;)/,
           `Expand<$1 & { ${layoutQueries.map((query) => {
             const name2 = query.name.value;
@@ -294586,15 +294594,15 @@ type LoadInput = { ${queries.filter((query) => query.variableDefinitions?.length
     return [name2, name2 + "$input"].join(": ");
   }).join("; ")} };` : ""}`;
 }
-function append_afterLoad(type, afterLoad, queries) {
+function append_afterLoad(afterLoad, type, queries) {
   return afterLoad ? `
-type AfterLoadReturn = ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>;
+type AfterLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').afterLoad>>;
 type AfterLoadData = {
 	${internal_append_afterLoad(queries)}
 };
 
 export type AfterLoadEvent = {
-	event: PageLoadEvent
+	event: ${type}LoadEvent
 	data: AfterLoadData
 	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? "LoadInput" : "{}"}
 };
@@ -294606,15 +294614,15 @@ function internal_append_afterLoad(queries) {
     return [name2, name2 + "$result"].join(": ");
   }).join(";\n	")}`;
 }
-function append_beforeLoad(beforeLoad) {
+function append_beforeLoad(beforeLoad, type) {
   return beforeLoad ? `
-export type BeforeLoadEvent = PageLoadEvent;
-type BeforeLoadReturn = ReturnType<typeof import('./+page').beforeLoad>;
+export type BeforeLoadEvent = ${type}LoadEvent;
+type BeforeLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').beforeLoad>>;
 ` : "";
 }
-function append_onError(onError, hasLoadInput) {
+function append_onError(onError, type, hasLoadInput) {
   return onError ? `
-type OnErrorReturn = ReturnType<typeof import('./+page').onError>;
+type OnErrorReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').onError>>;
 export type OnErrorEvent =  { event: Kit.LoadEvent, input: ${hasLoadInput ? "LoadInput" : "{}"}, error: Error | Error[] };
 ` : "";
 }
@@ -294763,8 +294771,6 @@ async function queryStore({ config: config3, plugin_root }, doc) {
   const storeData = `${statement}
 import artifact from '$houdini/artifacts/${artifactName}'
 
-// create the query store
-
 export class ${storeName} extends ${store_class} {
 	constructor() {
 		super({
@@ -294794,16 +294800,78 @@ export default ${globalStoreName}
   const typeDefs = `import type { ${_input}, ${_data}, ${store_class}, QueryStoreFetchParams} from '$houdini'
 
 export declare class ${storeName} extends ${store_class}<${_data}, ${_input}> {
+	/**
+	 * ### Route Loads
+	 * In a route's load function, manually instantiating a store can be used to look at the result:
+	 * 
+	 * \`\`\`js
+	 * export async function load(event) {
+	 * 	const store = new ${storeName}Store()
+	 * 	const { data } = await store.fetch({event})
+	 *  console.log('do something with', data)
+	 * 
+	 * 	return { 
+	 * 		${storeName}: store,
+	 * 	}
+	 * }
+	 * 
+	 * \`\`\`
+	 * 
+	 * ### Client Side Loading
+	 * When performing a client-side only fetch, the best practice to use a store _manually_ is to do the following:
+	 * 
+	 * \`\`\`js
+	 * const store = new ${storeName}Store()
+	 * 
+	 * $: browser && store.fetch({ variables });
+	 * \`\`\`
+	 */
 	constructor() {
 		// @ts-ignore
 		super({})
 	}
 }
 
-export const ${globalStoreName}: ${storeName}
-
+/**
+ * ### Manual Loads
+ * Usually your load function will look like this:
+ * 
+ * \`\`\`js
+ * import { load_${artifactName} } from '$houdini';
+ * import type { PageLoad } from './$types';
+ * 
+ * export const load: PageLoad = async (event) => {
+ *   const variables = {
+ *     id: // Something like: event.url.searchParams.get('id')
+ *   };
+ * 
+ *   return await load_${artifactName}({ event, variables });
+ * }; 
+ * \`\`\`
+ * 
+ * ### Multiple stores to load
+ * You can trigger them in parallel with \`loadAll\` function
+ * 
+ * \`\`\`js
+ * import { loadAll, load_${artifactName} } from '$houdini';
+ * import type { PageLoad } from './$types';
+ * 
+ * export const load: PageLoad = async (event) => {
+ *   const variables = {
+ *     id: // Something like: event.url.searchParams.get('id')
+ *   };
+ * 
+ *   return await await loadAll(
+ *     load_${artifactName}({ event, variables }),
+ *     // load_ANOTHER_STORE
+ *   );
+ * }; 
+ * \`\`\`
+ */
 export declare const load_${artifactName}: (params: QueryStoreFetchParams<${_data}, ${_input}>) => Promise<{${artifactName}: ${storeName}}>
 
+export const ${globalStoreName}: ${storeName}
+
 export default ${storeName}
 `;
   await Promise.all([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini-svelte",
-  "version": "0.17.11",
+  "version": "0.17.13",
   "description": "The svelte plugin for houdini",
   "keywords": [
     "typescript",
@@ -23,15 +23,15 @@
     "ast-types": "^0.15.1",
     "estree-walker": "^3.0.1",
     "graphql": "^15.8.0",
-    "houdini": "^0.17.11",
     "minimatch": "^5.1.0",
     "recast": "^0.21.5",
-    "svelte": "^3.52.0"
+    "svelte": "^3.52.0",
+    "houdini": "^0.17.13"
   },
   "devDependencies": {
     "@types/minimatch": "^5.1.2",
-    "scripts": "^1.0.0",
-    "vitest": "^0.23.4"
+    "vitest": "^0.23.4",
+    "scripts": "^1.0.0"
   },
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0"