houdini-svelte 0.17.12 → 0.17.13

package/build/plugin-cjs/index.js

@@ -179958,7 +179958,7 @@ type AfterLoadData = {
 };
 
 export type AfterLoadEvent = {
-	event: PageLoadEvent
+	event: ${type}LoadEvent
 	data: AfterLoadData
 	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? "LoadInput" : "{}"}
 };
@@ -179972,7 +179972,7 @@ function internal_append_afterLoad(queries) {
 }
 function append_beforeLoad(beforeLoad, type) {
   return beforeLoad ? `
-export type BeforeLoadEvent = PageLoadEvent;
+export type BeforeLoadEvent = ${type}LoadEvent;
 type BeforeLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').beforeLoad>>;
 ` : "";
 }
@@ -180127,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({
@@ -180158,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

@@ -179954,7 +179954,7 @@ type AfterLoadData = {
 };
 
 export type AfterLoadEvent = {
-	event: PageLoadEvent
+	event: ${type}LoadEvent
 	data: AfterLoadData
 	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? "LoadInput" : "{}"}
 };
@@ -179968,7 +179968,7 @@ function internal_append_afterLoad(queries) {
 }
 function append_beforeLoad(beforeLoad, type) {
   return beforeLoad ? `
-export type BeforeLoadEvent = PageLoadEvent;
+export type BeforeLoadEvent = ${type}LoadEvent;
 type BeforeLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').beforeLoad>>;
 ` : "";
 }
@@ -180123,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({
@@ -180154,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

@@ -294613,7 +294613,7 @@ type AfterLoadData = {
 };
 
 export type AfterLoadEvent = {
-	event: PageLoadEvent
+	event: ${type}LoadEvent
 	data: AfterLoadData
 	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? "LoadInput" : "{}"}
 };
@@ -294627,7 +294627,7 @@ function internal_append_afterLoad(queries) {
 }
 function append_beforeLoad(beforeLoad, type) {
   return beforeLoad ? `
-export type BeforeLoadEvent = PageLoadEvent;
+export type BeforeLoadEvent = ${type}LoadEvent;
 type BeforeLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').beforeLoad>>;
 ` : "";
 }
@@ -294782,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({
@@ -294813,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

@@ -294602,7 +294602,7 @@ type AfterLoadData = {
 };
 
 export type AfterLoadEvent = {
-	event: PageLoadEvent
+	event: ${type}LoadEvent
 	data: AfterLoadData
 	input: ${queries.filter((q) => q.variableDefinitions?.length).length ? "LoadInput" : "{}"}
 };
@@ -294616,7 +294616,7 @@ function internal_append_afterLoad(queries) {
 }
 function append_beforeLoad(beforeLoad, type) {
   return beforeLoad ? `
-export type BeforeLoadEvent = PageLoadEvent;
+export type BeforeLoadEvent = ${type}LoadEvent;
 type BeforeLoadReturn = Awaited<ReturnType<typeof import('./+${type.toLowerCase()}').beforeLoad>>;
 ` : "";
 }
@@ -294771,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({
@@ -294802,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.12",
+  "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.12",
     "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"