From eac2d015154b2228b22490a1da2ebc6d629f88d2 Mon Sep 17 00:00:00 2001
From: rossrobino <rbrobino@gmail.com>
Date: Mon, 8 Jan 2024 12:03:22 -0500
Subject: [PATCH 01/13] feat: add experimental client prerender

---
 packages/astro/src/@types/astro.ts            | 15 ++++++++
 packages/astro/src/core/config/schema.ts      |  5 +++
 packages/astro/src/prefetch/index.ts          | 34 ++++++++++++++++++-
 .../src/prefetch/vite-plugin-prefetch.ts      |  6 +++-
 4 files changed, 58 insertions(+), 2 deletions(-)

diff --git a/packages/astro/src/@types/astro.ts b/packages/astro/src/@types/astro.ts
index 97429212c698..089185024f36 100644
--- a/packages/astro/src/@types/astro.ts
+++ b/packages/astro/src/@types/astro.ts
@@ -1566,6 +1566,21 @@ export interface AstroUserConfig {
 		 * ```
 		 */
 		contentCollectionCache?: boolean;
+
+		/**
+		 * @docs
+		 * @name experimental.clientPrerender
+		 * @type {boolean}
+		 * @default `false`
+		 * @description
+		 * Progressive enhancement to use the experimental Speculation Rules API
+		 * when supported to prerender on the client. Use this setting to prerender the
+		 * page on the client, including running client side JavaScript
+		 * (see [unsafe prefetching](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API#unsafe_prefetching)).
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API)
+		 */
+		clientPrerender?: boolean;
 	};
 }
 
diff --git a/packages/astro/src/core/config/schema.ts b/packages/astro/src/core/config/schema.ts
index 5d30d1b5305c..7be8043c08ab 100644
--- a/packages/astro/src/core/config/schema.ts
+++ b/packages/astro/src/core/config/schema.ts
@@ -58,6 +58,7 @@ const ASTRO_CONFIG_DEFAULTS = {
 	experimental: {
 		optimizeHoistedScript: false,
 		contentCollectionCache: false,
+		clientPrerender: false,
 	},
 } satisfies AstroUserConfig & { server: { open: boolean } };
 
@@ -393,6 +394,10 @@ export const AstroConfigSchema = z.object({
 				.boolean()
 				.optional()
 				.default(ASTRO_CONFIG_DEFAULTS.experimental.contentCollectionCache),
+			clientPrerender: z
+				.boolean()
+				.optional()
+				.default(ASTRO_CONFIG_DEFAULTS.experimental.clientPrerender),
 		})
 		.strict(
 			`Invalid or outdated experimental feature.\nCheck for incorrect spelling or outdated Astro version.\nSee https://docs.astro.build/en/reference/configuration-reference/#experimental-flags for a list of all current experiments.`
diff --git a/packages/astro/src/prefetch/index.ts b/packages/astro/src/prefetch/index.ts
index 99cf3627af8e..d78e98e19d9b 100644
--- a/packages/astro/src/prefetch/index.ts
+++ b/packages/astro/src/prefetch/index.ts
@@ -16,6 +16,8 @@ const listenedAnchors = new WeakSet<HTMLAnchorElement>();
 let prefetchAll: boolean = __PREFETCH_PREFETCH_ALL__;
 // @ts-expect-error injected global
 let defaultStrategy: string = __PREFETCH_DEFAULT_STRATEGY__;
+// @ts-expect-error injected global
+let clientPrerender: boolean = __EXPERIMENTAL_CLIENT_PRERENDER__;
 
 interface InitOptions {
 	defaultStrategy?: string;
@@ -216,7 +218,14 @@ export function prefetch(url: string, opts?: PrefetchOptions) {
 	const priority = opts?.with ?? 'link';
 	debug?.(`[astro] Prefetching ${url} with ${priority}`);
 
-	if (priority === 'link') {
+	if (
+		clientPrerender &&
+		HTMLScriptElement.supports &&
+		HTMLScriptElement.supports('speculationrules')
+	) {
+		// this code is tree-shaken if unused
+		appendSpeculationRules(url);
+	} else if (priority === 'link') {
 		const link = document.createElement('link');
 		link.rel = 'prefetch';
 		link.setAttribute('href', url);
@@ -301,3 +310,26 @@ function onPageLoad(cb: () => void) {
 		cb();
 	});
 }
+
+/**
+ * Appends a `<script type="speculationRules">` tag to the head of the
+ * document that prerenders the `url` passed in.
+ *
+ * Modifying the script and appending a new link does not trigger the prerender.
+ * A new script must be added for each `url`.
+ *
+ * @param url The url of the page to prerender.
+ */
+function appendSpeculationRules(url: string) {
+	const script = document.createElement('script');
+	script.type = 'speculationrules';
+	script.textContent = JSON.stringify({
+		prerender: [
+			{
+				source: 'list',
+				urls: [url],
+			},
+		],
+	});
+	document.head.append(script);
+}
diff --git a/packages/astro/src/prefetch/vite-plugin-prefetch.ts b/packages/astro/src/prefetch/vite-plugin-prefetch.ts
index 83c3c3ff7c59..2f50f67af288 100644
--- a/packages/astro/src/prefetch/vite-plugin-prefetch.ts
+++ b/packages/astro/src/prefetch/vite-plugin-prefetch.ts
@@ -49,7 +49,11 @@ export default function astroPrefetch({ settings }: { settings: AstroSettings })
 			if (id.includes(prefetchInternalModuleFsSubpath)) {
 				return code
 					.replace('__PREFETCH_PREFETCH_ALL__', JSON.stringify(prefetch?.prefetchAll))
-					.replace('__PREFETCH_DEFAULT_STRATEGY__', JSON.stringify(prefetch?.defaultStrategy));
+					.replace('__PREFETCH_DEFAULT_STRATEGY__', JSON.stringify(prefetch?.defaultStrategy))
+					.replace(
+						'__EXPERIMENTAL_CLIENT_PRERENDER__',
+						JSON.stringify(settings.config.experimental.clientPrerender)
+					);
 			}
 		},
 	};

From fdfc86112c9445b45d4a5b86d67ae9006dd39af3 Mon Sep 17 00:00:00 2001
From: Ross Robino <ross@robino.dev>
Date: Sat, 13 Jan 2024 09:40:18 -0500
Subject: [PATCH 02/13] Update packages/astro/src/@types/astro.ts

Co-authored-by: Sarah Rainsberger <sarah@rainsberger.ca>
---
 packages/astro/src/@types/astro.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/astro/src/@types/astro.ts b/packages/astro/src/@types/astro.ts
index d3a23e68339f..6b72913b0d35 100644
--- a/packages/astro/src/@types/astro.ts
+++ b/packages/astro/src/@types/astro.ts
@@ -1572,6 +1572,7 @@ export interface AstroUserConfig {
 		 * @name experimental.clientPrerender
 		 * @type {boolean}
 		 * @default `false`
+		 * @version: 4.2.0
 		 * @description
 		 * Progressive enhancement to use the experimental Speculation Rules API
 		 * when supported to prerender on the client. Use this setting to prerender the

From 66342fac31cbacdae99534f63ba7c72d26916238 Mon Sep 17 00:00:00 2001
From: rossrobino <rbrobino@gmail.com>
Date: Sat, 13 Jan 2024 10:14:28 -0500
Subject: [PATCH 03/13] docs: add more details about effects of the feature

---
 packages/astro/src/@types/astro.ts | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/packages/astro/src/@types/astro.ts b/packages/astro/src/@types/astro.ts
index 6b72913b0d35..b118fb4c8024 100644
--- a/packages/astro/src/@types/astro.ts
+++ b/packages/astro/src/@types/astro.ts
@@ -1574,12 +1574,24 @@ export interface AstroUserConfig {
 		 * @default `false`
 		 * @version: 4.2.0
 		 * @description
-		 * Progressive enhancement to use the experimental Speculation Rules API
-		 * when supported to prerender on the client. Use this setting to prerender the
-		 * page on the client, including running client side JavaScript
-		 * (see [unsafe prefetching](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API#unsafe_prefetching)).
+		 * Enables pre-rendering a page on the client in supported browsers, including running client-side JavaScript.
 		 *
-		 * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API)
+		 * This feature uses the experimental [Speculation Rules Web API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API).
+		 * You may wish to review the [possible risks when prerendering on the client](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API#unsafe_prefetching) before enabling this feature.
+		 *
+		 * Enable client side prerendering in your `astro.config`, no additional configuration is required.
+		 *
+		 * ```js
+		 * {
+		 * 	experimental: {
+		 * 		clientPrerender: true,
+		 * 	},
+		 * }
+		 * ```
+		 *
+		 * - This feature enhances the existing prefetch capability Astro provides. All client side JavaScript will be executed during the prerender to create a faster experience and reduce layout shift.
+		 * - Enabling this feature overrides the default prefetch behavior globally for all links that match your prefetch strategy. Instead of appending a `link` tag to the head of the document or fetching the page with JavaScript, a `script` tag will be appended with the corresponding speculation rules.
+		 * - Client side prerendering works based on browser support, if the Speculation Rules API is not supported, prefetch will fallback to the supported strategy.
 		 */
 		clientPrerender?: boolean;
 	};

From 32f82b5158897e124231f087cbe478dee40e8ba6 Mon Sep 17 00:00:00 2001
From: rossrobino <rbrobino@gmail.com>
Date: Sat, 13 Jan 2024 10:23:25 -0500
Subject: [PATCH 04/13] add changeset

---
 .changeset/sixty-dogs-sneeze.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 .changeset/sixty-dogs-sneeze.md

diff --git a/.changeset/sixty-dogs-sneeze.md b/.changeset/sixty-dogs-sneeze.md
new file mode 100644
index 000000000000..0e00074f7ac7
--- /dev/null
+++ b/.changeset/sixty-dogs-sneeze.md
@@ -0,0 +1,5 @@
+---
+"astro": minor
+---
+
+Adds an experimental option to prefetch to prerender pages on the client with the Speculation Rules API when supported.

From 3ab937a7e1f8f4e08ec75c5dd9378a7b064c143a Mon Sep 17 00:00:00 2001
From: rossrobino <rbrobino@gmail.com>
Date: Sat, 13 Jan 2024 14:58:20 -0500
Subject: [PATCH 05/13] add tests

---
 packages/astro/e2e/prefetch.test.js | 103 ++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)

diff --git a/packages/astro/e2e/prefetch.test.js b/packages/astro/e2e/prefetch.test.js
index 12aa770029c2..72713a0fc67a 100644
--- a/packages/astro/e2e/prefetch.test.js
+++ b/packages/astro/e2e/prefetch.test.js
@@ -284,3 +284,106 @@ test.describe("Prefetch (prefetchAll: true, defaultStrategy: 'load')", () => {
 		expect(page.locator('link[rel="prefetch"][href$="/prefetch-load"]')).toBeDefined();
 	});
 });
+
+// Playwrights `request` event does not appear to fire when using the speculation rules API
+// Instead of checking for the added url, each test checks to see if `document.head`
+// contains a `script[type=speculationrules]` that has the `url` in it.
+test.describe('Prefetch (default), Experimental ({ clientPrerender: true })', () => {
+	/**
+	 * @param {import('@playwright/test').Page} page
+	 * @param {string} url
+	 * @returns the number of script[type=speculationrules] that have the url
+	 */
+	async function scriptIsInHead(page, url) {
+		return await page.evaluate((testUrl) => {
+			const scripts = document.head.querySelectorAll('script[type="speculationrules"]');
+			let count = 0;
+			for (const script of scripts) {
+				/** @type {{ prerender: { urls: string[] }[] }} */
+				const speculationRules = JSON.parse(script.textContent);
+				const specUrl = speculationRules.prerender.at(0).urls.at(0);
+				const indexOf = specUrl.indexOf(testUrl);
+				if (indexOf > -1) count++;
+			}
+			return count;
+		}, url);
+	}
+
+	let devServer;
+
+	test.beforeAll(async ({ astro }) => {
+		devServer = await astro.startDevServer({
+			experimental: {
+				clientPrerender: true,
+			},
+		});
+	});
+
+	test.afterAll(async () => {
+		await devServer.stop();
+	});
+
+	test('Link without data-astro-prefetch should not prefetch', async ({ page, astro }) => {
+		await page.goto(astro.resolveUrl('/'));
+		expect(await scriptIsInHead(page, '/prefetch-default')).toBeFalsy();
+	});
+
+	test('data-astro-prefetch="false" should not prefetch', async ({ page, astro }) => {
+		await page.goto(astro.resolveUrl('/'));
+		expect(await scriptIsInHead(page, '/prefetch-false')).toBeFalsy();
+	});
+
+	test('Link with search param should prefetch', async ({ page, astro }) => {
+		await page.goto(astro.resolveUrl('/'));
+		expect(await scriptIsInHead(page, '?search-param=true')).toBeFalsy();
+		await page.locator('#prefetch-search-param').hover();
+		await page.waitForFunction(
+			() => document.querySelectorAll('script[type=speculationrules]').length === 2
+		);
+		expect(await scriptIsInHead(page, '?search-param=true')).toBeTruthy();
+	});
+
+	test('data-astro-prefetch="tap" should prefetch on tap', async ({ page, astro }) => {
+		await page.goto(astro.resolveUrl('/'));
+		expect(await scriptIsInHead(page, '/prefetch-tap')).toBeFalsy();
+		await page.locator('#prefetch-tap').dragTo(page.locator('#prefetch-hover'));
+		expect(await scriptIsInHead(page, '/prefetch-tap')).toBeTruthy();
+	});
+
+	test('data-astro-prefetch="hover" should prefetch on hover', async ({ page, astro }) => {
+		await page.goto(astro.resolveUrl('/'));
+		expect(await scriptIsInHead(page, '/prefetch-hover')).toBeFalsy();
+		await page.locator('#prefetch-hover').hover();
+		await page.waitForFunction(
+			() => document.querySelectorAll('script[type=speculationrules]').length === 2
+		);
+		expect(await scriptIsInHead(page, '/prefetch-hover')).toBeTruthy();
+	});
+
+	test('data-astro-prefetch="viewport" should prefetch on viewport', async ({ page, astro }) => {
+		await page.goto(astro.resolveUrl('/'));
+		expect(await scriptIsInHead(page, '/prefetch-viewport')).toBeFalsy();
+		// Scroll down to show the element
+		await page.locator('#prefetch-viewport').scrollIntoViewIfNeeded();
+		await page.waitForFunction(
+			() => document.querySelectorAll('script[type=speculationrules]').length === 2
+		);
+		expect(await scriptIsInHead(page, '/prefetch-viewport')).toBeTruthy();
+	});
+
+	test('manual prefetch() works once', async ({ page, astro }) => {
+		await page.goto(astro.resolveUrl('/'));
+		expect(await scriptIsInHead(page, '/prefetch-manual')).toEqual(0);
+		await page.locator('#prefetch-manual').click();
+		expect(await scriptIsInHead(page, '/prefetch-manual')).toEqual(1);
+
+		// prefetch again should have no effect
+		await page.locator('#prefetch-manual').click();
+		expect(await scriptIsInHead(page, '/prefetch-manual')).toEqual(1);
+	});
+
+	test('data-astro-prefetch="load" should prefetch', async ({ page, astro }) => {
+		await page.goto(astro.resolveUrl('/'));
+		expect(await scriptIsInHead(page, 'prefetch-load')).toBeTruthy();
+	});
+});

From a6977a40afaa38816851c06dd7b0972f51aed213 Mon Sep 17 00:00:00 2001
From: rossrobino <rbrobino@gmail.com>
Date: Mon, 15 Jan 2024 09:11:55 -0500
Subject: [PATCH 06/13] edit jsdoc and changeset with suggestions

---
 .changeset/sixty-dogs-sneeze.md    | 21 ++++++++++++++++++++-
 packages/astro/src/@types/astro.ts | 21 +++++++++++++++------
 2 files changed, 35 insertions(+), 7 deletions(-)

diff --git a/.changeset/sixty-dogs-sneeze.md b/.changeset/sixty-dogs-sneeze.md
index 0e00074f7ac7..dd22ee88d9de 100644
--- a/.changeset/sixty-dogs-sneeze.md
+++ b/.changeset/sixty-dogs-sneeze.md
@@ -2,4 +2,23 @@
 "astro": minor
 ---
 
-Adds an experimental option to prefetch to prerender pages on the client with the Speculation Rules API when supported.
+Adds an experimental flag `clientPrerender` to pre-render your prefetched pages on the client with the [Speculation Rules API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API).
+
+```js
+// astro.config.mjs
+{
+  prefetch: {
+    prefetchAll: true,
+    defaultStrategy: viewport,
+  }
+  experimental: {
+    clientPrerender: true,
+  },
+}
+```
+
+Enabling this feature overrides the default `prefetch` behavior globally to pre-render links on the client according to your `prefetch` configuration. Instead of appending a `<link>` tag to the head of the document or fetching the page with JavaScript, a `<script>` tag will be appended with the corresponding speculation rules.
+
+Client side pre-rendering requires browser support. If the Speculation Rules API is not supported, `prefetch` will fallback to the supported strategy.
+
+See the [Prefetch Guide](https://docs.astro.build/en/guides/prefetch/) for more `prefetch` options and usage.
\ No newline at end of file
diff --git a/packages/astro/src/@types/astro.ts b/packages/astro/src/@types/astro.ts
index b118fb4c8024..53d9ba196e4d 100644
--- a/packages/astro/src/@types/astro.ts
+++ b/packages/astro/src/@types/astro.ts
@@ -1574,24 +1574,33 @@ export interface AstroUserConfig {
 		 * @default `false`
 		 * @version: 4.2.0
 		 * @description
-		 * Enables pre-rendering a page on the client in supported browsers, including running client-side JavaScript.
+		 * Enables pre-rendering your prefetched pages on the client in supported browsers.
 		 *
-		 * This feature uses the experimental [Speculation Rules Web API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API).
+		 * This feature uses the experimental [Speculation Rules Web API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API) and overrides the default `prefetch` behavior globally to pre-render links on the client.
 		 * You may wish to review the [possible risks when prerendering on the client](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API#unsafe_prefetching) before enabling this feature.
 		 *
-		 * Enable client side prerendering in your `astro.config`, no additional configuration is required.
+		 * Enable client side pre-rendering in your `astro.config.mjs` along with any desired `prefetch` configuration options:
 		 *
 		 * ```js
+		 * // astro.config.mjs
 		 * {
+		 *   prefetch: {
+		 *     prefetchAll: true,
+		 *     defaultStrategy: viewport,
+		 *   }
 		 * 	experimental: {
 		 * 		clientPrerender: true,
 		 * 	},
 		 * }
 		 * ```
 		 *
-		 * - This feature enhances the existing prefetch capability Astro provides. All client side JavaScript will be executed during the prerender to create a faster experience and reduce layout shift.
-		 * - Enabling this feature overrides the default prefetch behavior globally for all links that match your prefetch strategy. Instead of appending a `link` tag to the head of the document or fetching the page with JavaScript, a `script` tag will be appended with the corresponding speculation rules.
-		 * - Client side prerendering works based on browser support, if the Speculation Rules API is not supported, prefetch will fallback to the supported strategy.
+		 * Continue to use the `data-astro-prefetch` attribute on any `<a />` link on your site to opt in to prefetching.
+		 *
+		 * Instead of appending a `<link>` tag to the head of the document or fetching the page with JavaScript, a `<script>` tag will be appended with the corresponding speculation rules.
+		 *
+		 * Client side pre-rendering requires browser support. If the Speculation Rules API is not supported, `prefetch` will fallback to the supported strategy.
+		 *
+		 * See the [Prefetch Guide](https://docs.astro.build/en/guides/prefetch/) for more `prefetch` options and usage.
 		 */
 		clientPrerender?: boolean;
 	};

From 9b7bed482015f571ad5689739b0e85bef4f3218b Mon Sep 17 00:00:00 2001
From: Ross Robino <ross@robino.dev>
Date: Mon, 15 Jan 2024 10:44:55 -0500
Subject: [PATCH 07/13] Update packages/astro/src/@types/astro.ts

Co-authored-by: Bjorn Lu <bjornlu.dev@gmail.com>
---
 packages/astro/src/@types/astro.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/astro/src/@types/astro.ts b/packages/astro/src/@types/astro.ts
index 53d9ba196e4d..e1d5ce16a02d 100644
--- a/packages/astro/src/@types/astro.ts
+++ b/packages/astro/src/@types/astro.ts
@@ -1586,8 +1586,8 @@ export interface AstroUserConfig {
 		 * {
 		 *   prefetch: {
 		 *     prefetchAll: true,
-		 *     defaultStrategy: viewport,
-		 *   }
+		 *     defaultStrategy: 'viewport',
+		 *   },
 		 * 	experimental: {
 		 * 		clientPrerender: true,
 		 * 	},

From d9069db6db8343c9933b8323b1f191c39b39e578 Mon Sep 17 00:00:00 2001
From: Ross Robino <ross@robino.dev>
Date: Mon, 15 Jan 2024 10:45:09 -0500
Subject: [PATCH 08/13] Update packages/astro/src/prefetch/index.ts

Co-authored-by: Bjorn Lu <bjornlu.dev@gmail.com>
---
 packages/astro/src/prefetch/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/astro/src/prefetch/index.ts b/packages/astro/src/prefetch/index.ts
index d78e98e19d9b..b56f9fffd2c4 100644
--- a/packages/astro/src/prefetch/index.ts
+++ b/packages/astro/src/prefetch/index.ts
@@ -312,7 +312,7 @@ function onPageLoad(cb: () => void) {
 }
 
 /**
- * Appends a `<script type="speculationRules">` tag to the head of the
+ * Appends a `<script type="speculationrules">` tag to the head of the
  * document that prerenders the `url` passed in.
  *
  * Modifying the script and appending a new link does not trigger the prerender.

From 182291cad34d0eb5ad20ff69dc03cfe0d10d3086 Mon Sep 17 00:00:00 2001
From: Ross Robino <ross@robino.dev>
Date: Mon, 15 Jan 2024 10:46:13 -0500
Subject: [PATCH 09/13] Update .changeset/sixty-dogs-sneeze.md

Co-authored-by: Sarah Rainsberger <sarah@rainsberger.ca>
---
 .changeset/sixty-dogs-sneeze.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.changeset/sixty-dogs-sneeze.md b/.changeset/sixty-dogs-sneeze.md
index dd22ee88d9de..f5d83097c89d 100644
--- a/.changeset/sixty-dogs-sneeze.md
+++ b/.changeset/sixty-dogs-sneeze.md
@@ -9,8 +9,8 @@ Adds an experimental flag `clientPrerender` to pre-render your prefetched pages
 {
   prefetch: {
     prefetchAll: true,
-    defaultStrategy: viewport,
-  }
+    defaultStrategy: 'viewport',
+  },
   experimental: {
     clientPrerender: true,
   },

From 1f32db23edd0d545aceb2c9de5a79c4001c1a174 Mon Sep 17 00:00:00 2001
From: Ross Robino <ross@robino.dev>
Date: Mon, 15 Jan 2024 10:46:42 -0500
Subject: [PATCH 10/13] Update packages/astro/src/@types/astro.ts

Co-authored-by: Sarah Rainsberger <sarah@rainsberger.ca>
---
 packages/astro/src/@types/astro.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/packages/astro/src/@types/astro.ts b/packages/astro/src/@types/astro.ts
index e1d5ce16a02d..927c165e32c4 100644
--- a/packages/astro/src/@types/astro.ts
+++ b/packages/astro/src/@types/astro.ts
@@ -1595,10 +1595,9 @@ export interface AstroUserConfig {
 		 * ```
 		 *
 		 * Continue to use the `data-astro-prefetch` attribute on any `<a />` link on your site to opt in to prefetching.
-		 *
 		 * Instead of appending a `<link>` tag to the head of the document or fetching the page with JavaScript, a `<script>` tag will be appended with the corresponding speculation rules.
 		 *
-		 * Client side pre-rendering requires browser support. If the Speculation Rules API is not supported, `prefetch` will fallback to the supported strategy.
+		 * Client side prerendering requires browser support. If the Speculation Rules API is not supported, `prefetch` will fallback to the supported strategy.
 		 *
 		 * See the [Prefetch Guide](https://docs.astro.build/en/guides/prefetch/) for more `prefetch` options and usage.
 		 */

From 53b2d7881ce9fd1951e46e5999698471496e4df3 Mon Sep 17 00:00:00 2001
From: Ross Robino <ross@robino.dev>
Date: Mon, 15 Jan 2024 10:46:52 -0500
Subject: [PATCH 11/13] Update .changeset/sixty-dogs-sneeze.md

Co-authored-by: Sarah Rainsberger <sarah@rainsberger.ca>
---
 .changeset/sixty-dogs-sneeze.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.changeset/sixty-dogs-sneeze.md b/.changeset/sixty-dogs-sneeze.md
index f5d83097c89d..af563f925364 100644
--- a/.changeset/sixty-dogs-sneeze.md
+++ b/.changeset/sixty-dogs-sneeze.md
@@ -17,8 +17,8 @@ Adds an experimental flag `clientPrerender` to pre-render your prefetched pages
 }
 ```
 
-Enabling this feature overrides the default `prefetch` behavior globally to pre-render links on the client according to your `prefetch` configuration. Instead of appending a `<link>` tag to the head of the document or fetching the page with JavaScript, a `<script>` tag will be appended with the corresponding speculation rules.
+Enabling this feature overrides the default `prefetch` behavior globally to prerender links on the client according to your `prefetch` configuration. Instead of appending a `<link>` tag to the head of the document or fetching the page with JavaScript, a `<script>` tag will be appended with the corresponding speculation rules.
 
-Client side pre-rendering requires browser support. If the Speculation Rules API is not supported, `prefetch` will fallback to the supported strategy.
+Client side prerendering requires browser support. If the Speculation Rules API is not supported, `prefetch` will fallback to the supported strategy.
 
 See the [Prefetch Guide](https://docs.astro.build/en/guides/prefetch/) for more `prefetch` options and usage.
\ No newline at end of file

From d4d77bdc21c57ac905add9dac6daaf2bd1cd406c Mon Sep 17 00:00:00 2001
From: Ross Robino <ross@robino.dev>
Date: Mon, 15 Jan 2024 10:47:21 -0500
Subject: [PATCH 12/13] Update .changeset/sixty-dogs-sneeze.md

Co-authored-by: Sarah Rainsberger <sarah@rainsberger.ca>
---
 .changeset/sixty-dogs-sneeze.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.changeset/sixty-dogs-sneeze.md b/.changeset/sixty-dogs-sneeze.md
index af563f925364..13f89232898d 100644
--- a/.changeset/sixty-dogs-sneeze.md
+++ b/.changeset/sixty-dogs-sneeze.md
@@ -2,7 +2,7 @@
 "astro": minor
 ---
 
-Adds an experimental flag `clientPrerender` to pre-render your prefetched pages on the client with the [Speculation Rules API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API).
+Adds an experimental flag `clientPrerender` to prerender your prefetched pages on the client with the [Speculation Rules API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API).
 
 ```js
 // astro.config.mjs

From 17b6aff89ad27061286d7e704ce78f02c4293e30 Mon Sep 17 00:00:00 2001
From: Ross Robino <ross@robino.dev>
Date: Mon, 15 Jan 2024 10:47:32 -0500
Subject: [PATCH 13/13] Update packages/astro/src/@types/astro.ts

Co-authored-by: Sarah Rainsberger <sarah@rainsberger.ca>
---
 packages/astro/src/@types/astro.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/astro/src/@types/astro.ts b/packages/astro/src/@types/astro.ts
index 927c165e32c4..784bda56aeb8 100644
--- a/packages/astro/src/@types/astro.ts
+++ b/packages/astro/src/@types/astro.ts
@@ -1576,10 +1576,10 @@ export interface AstroUserConfig {
 		 * @description
 		 * Enables pre-rendering your prefetched pages on the client in supported browsers.
 		 *
-		 * This feature uses the experimental [Speculation Rules Web API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API) and overrides the default `prefetch` behavior globally to pre-render links on the client.
+		 * This feature uses the experimental [Speculation Rules Web API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API) and overrides the default `prefetch` behavior globally to prerender links on the client.
 		 * You may wish to review the [possible risks when prerendering on the client](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API#unsafe_prefetching) before enabling this feature.
 		 *
-		 * Enable client side pre-rendering in your `astro.config.mjs` along with any desired `prefetch` configuration options:
+		 * Enable client side prerendering in your `astro.config.mjs` along with any desired `prefetch` configuration options:
 		 *
 		 * ```js
 		 * // astro.config.mjs