From 0891ac9de5a6996e5ebd227e3443f7f4a4ea935a Mon Sep 17 00:00:00 2001
From: "Houston (Bot)" <108291165+astrobot-houston@users.noreply.github.com>
Date: Fri, 7 Aug 2026 08:11:44 -0700
Subject: [PATCH 1/7] Fix dynamic redirect routes ignoring configured status
 code in underscore-redirects (#17620)

* fix(underscore-redirects): use configured redirect status in dynamic branch

The dynamic-route branch of createRedirectsFromAstroRoutes hardcoded 301
for redirect routes, ignoring user-configured status codes. The static
branch already used getRedirectStatus(route) correctly.

Fixes #17619

* chore: add changeset
---
 .changeset/fix-dynamic-redirect-status.md     |  5 ++
 packages/underscore-redirects/src/astro.ts    |  2 +-
 .../underscore-redirects/test/astro.test.ts   | 71 +++++++++++++++++++
 3 files changed, 77 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/fix-dynamic-redirect-status.md

diff --git a/.changeset/fix-dynamic-redirect-status.md b/.changeset/fix-dynamic-redirect-status.md
new file mode 100644
index 000000000000..cd1ff4444f52
--- /dev/null
+++ b/.changeset/fix-dynamic-redirect-status.md
@@ -0,0 +1,5 @@
+---
+'@astrojs/underscore-redirects': patch
+---
+
+Fixes dynamic redirect routes to honour user-configured status codes instead of hardcoding 301. Previously, a redirect configured with `{ destination: '/new', status: 302 }` would be emitted as 301 in the `_redirects` file when the route was dynamic.
diff --git a/packages/underscore-redirects/src/astro.ts b/packages/underscore-redirects/src/astro.ts
index 860a171eedf7..3e03c2e17152 100644
--- a/packages/underscore-redirects/src/astro.ts
+++ b/packages/underscore-redirects/src/astro.ts
@@ -153,7 +153,7 @@ export function createRedirectsFromAstroRoutes({
 					dynamic: true,
 					input: `${base}${pattern}`,
 					target,
-					status: route.type === 'redirect' ? 301 : 200,
+					status: route.type === 'redirect' ? getRedirectStatus(route) : 200,
 					weight: 1,
 				});
 			} else {
diff --git a/packages/underscore-redirects/test/astro.test.ts b/packages/underscore-redirects/test/astro.test.ts
index 623c7261f502..c378ea7d08be 100644
--- a/packages/underscore-redirects/test/astro.test.ts
+++ b/packages/underscore-redirects/test/astro.test.ts
@@ -48,6 +48,77 @@ describe('Astro', () => {
 		assert.deepEqual(getTrailingSlashPaths('/path', 'never'), ['/path']);
 		assert.deepEqual(getTrailingSlashPaths('/path/', 'never'), ['/path']);
 	});
+	it('Dynamic redirect honours configured status', () => {
+		const route = {
+			pattern: '/old/[id]',
+			pathname: undefined,
+			segments: [
+				[{ content: 'old', dynamic: false, spread: false }],
+				[{ content: 'id', dynamic: true, spread: false }],
+			],
+			type: 'redirect',
+			redirect: { destination: '/new/:id', status: 302 },
+			redirectRoute: {
+				pattern: '/new/[id]',
+				segments: [
+					[{ content: 'new', dynamic: false, spread: false }],
+					[{ content: 'id', dynamic: true, spread: false }],
+				],
+			},
+			entrypoint: '/old/[id]',
+			isPrerendered: true,
+			origin: 'internal',
+		} as unknown as IntegrationResolvedRoute;
+
+		const redirects = createRedirectsFromAstroRoutes({
+			config: {
+				build: { format: 'directory' },
+				trailingSlash: 'never',
+			} as AstroConfig,
+			routeToDynamicTargetMap: new Map([[route, '']]),
+			dir: new URL(import.meta.url),
+			buildOutput: 'server',
+			assets: new Map([['/old/[id]', [new URL('./old/index.html', import.meta.url)]]]),
+		});
+
+		assert.equal(redirects.definitions[0].status, 302);
+	});
+
+	it('Dynamic redirect defaults to 301 when redirect is a string', () => {
+		const route = {
+			pattern: '/old/[id]',
+			pathname: undefined,
+			segments: [
+				[{ content: 'old', dynamic: false, spread: false }],
+				[{ content: 'id', dynamic: true, spread: false }],
+			],
+			type: 'redirect',
+			redirect: '/new/:id',
+			redirectRoute: {
+				pattern: '/new/[id]',
+				segments: [
+					[{ content: 'new', dynamic: false, spread: false }],
+					[{ content: 'id', dynamic: true, spread: false }],
+				],
+			},
+			entrypoint: '/old/[id]',
+			isPrerendered: true,
+			origin: 'internal',
+		} as unknown as IntegrationResolvedRoute;
+
+		const redirects = createRedirectsFromAstroRoutes({
+			config: {
+				build: { format: 'directory' },
+				trailingSlash: 'never',
+			} as AstroConfig,
+			routeToDynamicTargetMap: new Map([[route, '']]),
+			dir: new URL(import.meta.url),
+			buildOutput: 'server',
+			assets: new Map([['/old/[id]', [new URL('./old/index.html', import.meta.url)]]]),
+		});
+
+		assert.equal(redirects.definitions[0].status, 301);
+	});
 });
 
 function createIntegrationRoute(pattern: string, pathname = pattern): IntegrationResolvedRoute {

From 5861cf5528096c36be05ce98fb233ffb811c1c7e Mon Sep 17 00:00:00 2001
From: mkismy <mkis.my@gmail.com>
Date: Sat, 8 Aug 2026 00:13:15 +0900
Subject: [PATCH 2/7] update: Basics template for Astro 7.0 (#17623)

---
 examples/basics/src/components/Welcome.astro | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/basics/src/components/Welcome.astro b/examples/basics/src/components/Welcome.astro
index 1b2cf9c416d0..6652a7541221 100644
--- a/examples/basics/src/components/Welcome.astro
+++ b/examples/basics/src/components/Welcome.astro
@@ -27,16 +27,16 @@ import background from '../assets/background.svg';
 		</section>
 	</main>
 
-	<a href="https://astro.build/blog/astro-6-beta/" id="news" class="box">
+	<a href="https://astro.build/blog/astro-7/" id="news" class="box">
 		<svg width="32" height="32" fill="none" xmlns="http://www.w3.org/2000/svg"
 			><path
 				d="M24.667 12c1.333 1.414 2 3.192 2 5.334 0 4.62-4.934 5.7-7.334 12C18.444 28.567 18 27.456 18 26c0-4.642 6.667-7.053 6.667-14Zm-5.334-5.333c1.6 1.65 2.4 3.43 2.4 5.333 0 6.602-8.06 7.59-6.4 17.334C13.111 27.787 12 25.564 12 22.666c0-4.434 7.333-8 7.333-16Zm-6-5.333C15.111 3.555 16 5.556 16 7.333c0 8.333-11.333 10.962-5.333 22-3.488-.774-6-4-6-8 0-8.667 8.666-10 8.666-20Z"
 				fill="#111827"></path></svg
 		>
-		<h2>What's New in Astro 6.0?</h2>
+		<h2>What's New in Astro 7.0?</h2>
 		<p>
-			Redesigned dev server, fonts, live collections, built-in CSP support, and more! Click to
-			explore Astro 6.0's new features.
+			Rust-powered compiler, advanced routing, AI agent support, and more! Click to explore Astro
+			7.0's new features.
 		</p>
 	</a>
 </div>

From ba6a9f6e4523fe4e88ea31d4664835d3ba1ff3bc Mon Sep 17 00:00:00 2001
From: "Houston (Bot)" <108291165+astrobot-houston@users.noreply.github.com>
Date: Fri, 7 Aug 2026 08:24:05 -0700
Subject: [PATCH 3/7] fix(cloudflare): bump astro peer dependency to ^7.2.0
 (#17627)

@astrojs/cloudflare@14.2.0 imports beginContentEntryCollection,
beginImageCollection, endContentEntryCollection, and endImageCollection
from astro/app, which were added in astro@7.2.0. The previous peer
dependency range of ^7.0.0 allowed resolution of astro@7.1.x, causing a
MISSING_EXPORT build failure.

Fixes #17622
---
 .changeset/fix-cloudflare-peer-dep.md         | 5 +++++
 packages/integrations/cloudflare/package.json | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/fix-cloudflare-peer-dep.md

diff --git a/.changeset/fix-cloudflare-peer-dep.md b/.changeset/fix-cloudflare-peer-dep.md
new file mode 100644
index 000000000000..ecd2995dba44
--- /dev/null
+++ b/.changeset/fix-cloudflare-peer-dep.md
@@ -0,0 +1,5 @@
+---
+'@astrojs/cloudflare': patch
+---
+
+Fixes the `astro` peer dependency range from `^7.0.0` to `^7.2.0`. The adapter imports symbols (`beginContentEntryCollection`, `beginImageCollection`, `endContentEntryCollection`, `endImageCollection`) from `astro/app` that were added in Astro 7.2.0, so earlier versions fail at build time with a `MISSING_EXPORT` error.
diff --git a/packages/integrations/cloudflare/package.json b/packages/integrations/cloudflare/package.json
index 2e9258ec394b..a836eeb93cea 100644
--- a/packages/integrations/cloudflare/package.json
+++ b/packages/integrations/cloudflare/package.json
@@ -51,7 +51,7 @@
     "vite": "^8.0.13"
   },
   "peerDependencies": {
-    "astro": "^7.0.0",
+    "astro": "^7.2.0",
     "wrangler": "^4.83.0"
   },
   "devDependencies": {

From 4ada24889fc1bcc1ee89f3f8e5c6bc4cbe87cce6 Mon Sep 17 00:00:00 2001
From: "Houston (Bot)" <108291165+astrobot-houston@users.noreply.github.com>
Date: Fri, 7 Aug 2026 08:41:43 -0700
Subject: [PATCH 4/7] fix(csp): include speculation rules hash in CSP when
 clientPrerender is enabled (#17628)

When both `security.csp` and `experimental.clientPrerender` are enabled,
the prefetch module's dynamic per-URL `<script type="speculationrules">`
injection causes CSP violations because the scripts' hashes are not in
the CSP policy.

Switch to a static `"source": "document"` approach with CSS selector
matching (`a[data-astro-prefetch]`) that produces a deterministic JSON
payload. The hash is computed at build time and included in the CSP
`script-src` directive. The client-side prefetch code detects static
rules and skips dynamic injection.

Fixes #17599
---
 .changeset/bumpy-drinks-doubt.md              |  5 +++
 packages/astro/src/core/app/types.ts          |  2 ++
 .../src/core/build/plugins/plugin-manifest.ts | 18 +++++++++-
 packages/astro/src/core/fetch/fetch-state.ts  |  1 +
 packages/astro/src/prefetch/index.ts          | 36 +++++++++++++++++--
 .../astro/src/prefetch/speculation-rules.ts   | 24 +++++++++++++
 .../astro/src/runtime/server/render/head.ts   | 13 +++++++
 packages/astro/src/types/public/internal.ts   |  2 ++
 .../test/units/csp/speculation-rules.test.ts  | 36 +++++++++++++++++++
 9 files changed, 134 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/bumpy-drinks-doubt.md
 create mode 100644 packages/astro/src/prefetch/speculation-rules.ts
 create mode 100644 packages/astro/test/units/csp/speculation-rules.test.ts

diff --git a/.changeset/bumpy-drinks-doubt.md b/.changeset/bumpy-drinks-doubt.md
new file mode 100644
index 000000000000..60ef4b9751dc
--- /dev/null
+++ b/.changeset/bumpy-drinks-doubt.md
@@ -0,0 +1,5 @@
+---
+'astro': patch
+---
+
+Fixes a CSP violation when using both `security.csp` and `experimental.clientPrerender` with `data-astro-prefetch` links. The dynamically injected `<script type="speculationrules">` now uses a static `"source": "document"` approach with a CSS selector, producing a deterministic payload that is hashed and included in the CSP `script-src` directive at build time.
diff --git a/packages/astro/src/core/app/types.ts b/packages/astro/src/core/app/types.ts
index 90b52ba12f59..9c0e476c3781 100644
--- a/packages/astro/src/core/app/types.ts
+++ b/packages/astro/src/core/app/types.ts
@@ -204,6 +204,8 @@ export type SSRManifestCSP = {
 		resources: CspResourceEntry[];
 		hashes: CspHashEntry[];
 	};
+	/** Static speculation rules JSON to inject in the head when CSP + clientPrerender are both enabled. */
+	speculationRulesContent?: string;
 };
 
 export interface SSRManifestSession extends BaseSessionConfig {
diff --git a/packages/astro/src/core/build/plugins/plugin-manifest.ts b/packages/astro/src/core/build/plugins/plugin-manifest.ts
index 6be012432f73..1279715de892 100644
--- a/packages/astro/src/core/build/plugins/plugin-manifest.ts
+++ b/packages/astro/src/core/build/plugins/plugin-manifest.ts
@@ -28,7 +28,8 @@ import {
 	trackStyleHashes,
 } from '../../csp/common.js';
 import { partitionByKind } from '../../csp/runtime.js';
-import { encodeKey } from '../../encryption.js';
+import { generateSpeculationRulesContent } from '../../../prefetch/speculation-rules.js';
+import { encodeKey, generateCspDigest } from '../../encryption.js';
 import { fileExtension, joinPaths, prependForwardSlash } from '../../path.js';
 import { DEFAULT_COMPONENTS } from '../../routing/default.js';
 import { getOutFile, getOutFolder } from '../common.js';
@@ -324,6 +325,20 @@ async function buildManifest(
 			...(await trackStyleHashes(internals, settings, algorithm)),
 		];
 
+		// When both CSP and clientPrerender are enabled, generate a static speculation rules
+		// script whose hash can be included in the CSP policy. Dynamic per-URL injection would
+		// produce unpredictable hashes that cannot be whitelisted at build time.
+		let speculationRulesContent: string | undefined;
+		if (settings.config.experimental.clientPrerender && settings.config.prefetch) {
+			const prefetchAll =
+				typeof settings.config.prefetch === 'object'
+					? (settings.config.prefetch.prefetchAll ?? false)
+					: false;
+			speculationRulesContent = generateSpeculationRulesContent(prefetchAll);
+			const speculationRulesHash = await generateCspDigest(speculationRulesContent, algorithm);
+			scriptHashes.push(speculationRulesHash);
+		}
+
 		const scriptDirective = {
 			resources: getScriptResources(cspConfig),
 			hashes: scriptHashes,
@@ -348,6 +363,7 @@ async function buildManifest(
 			styleResources: styleDefault.resources,
 			scriptDirective,
 			styleDirective,
+			speculationRulesContent,
 		};
 	}
 
diff --git a/packages/astro/src/core/fetch/fetch-state.ts b/packages/astro/src/core/fetch/fetch-state.ts
index 26047d7dad1b..a04950ff4bb4 100644
--- a/packages/astro/src/core/fetch/fetch-state.ts
+++ b/packages/astro/src/core/fetch/fetch-state.ts
@@ -453,6 +453,7 @@ export class FetchState implements AstroFetchState {
 				resources: manifest.csp?.styleDirective ? [...manifest.csp.styleDirective.resources] : [],
 				hashes: manifest.csp?.styleDirective ? [...manifest.csp.styleDirective.hashes] : [],
 			},
+			speculationRulesContent: manifest.csp?.speculationRulesContent,
 			internalFetchHeaders: manifest.internalFetchHeaders,
 		};
 
diff --git a/packages/astro/src/prefetch/index.ts b/packages/astro/src/prefetch/index.ts
index 013fac0bb368..b0599f45a51c 100644
--- a/packages/astro/src/prefetch/index.ts
+++ b/packages/astro/src/prefetch/index.ts
@@ -225,9 +225,15 @@ export function prefetch(url: string, opts?: PrefetchOptions) {
 	if (!canPrefetchUrl(url, ignoreSlowConnection)) return;
 	prefetchedUrls.add(url);
 
-	// Prefetch with speculationrules if `clientPrerender` is enabled and supported
+	// Prefetch with speculationrules if `clientPrerender` is enabled and supported.
+	// Skip dynamic injection when a static document-source speculation rules script is already
+	// in the page (injected at build time for CSP compatibility).
 	// NOTE: This condition is tree-shaken if `clientPrerender` is false as its a static value
-	if (clientPrerender && HTMLScriptElement.supports?.('speculationrules')) {
+	if (
+		clientPrerender &&
+		HTMLScriptElement.supports?.('speculationrules') &&
+		!hasStaticSpeculationRules()
+	) {
 		debug?.(`[astro] Prefetching ${url} with <script type="speculationrules">`);
 		appendSpeculationRules(url, opts?.eagerness ?? 'immediate');
 	}
@@ -340,6 +346,32 @@ function onPageLoad(cb: () => void) {
 	}).observe(document.body, { childList: true, subtree: true });
 }
 
+/** Cached result of static speculation rules detection. */
+let _hasStaticRules: boolean | undefined;
+
+/**
+ * Returns `true` when a `<script type="speculationrules">` using `"source": "document"`
+ * is already present in the page (injected server-side for CSP compatibility).
+ * The browser handles URL matching via CSS selectors in that case, so per-URL
+ * dynamic injection is unnecessary.
+ */
+function hasStaticSpeculationRules(): boolean {
+	if (_hasStaticRules === undefined) {
+		_hasStaticRules = Array.from(document.querySelectorAll('script[type="speculationrules"]')).some(
+			(el) => {
+				try {
+					const rules = JSON.parse(el.textContent ?? '');
+					const entries = [...(rules.prerender ?? []), ...(rules.prefetch ?? [])];
+					return entries.some((entry: any) => entry.source === 'document');
+				} catch {
+					return false;
+				}
+			},
+		);
+	}
+	return _hasStaticRules;
+}
+
 /**
  * Appends a `<script type="speculationrules">` tag to the head of the
  * document that prerenders the `url` passed in.
diff --git a/packages/astro/src/prefetch/speculation-rules.ts b/packages/astro/src/prefetch/speculation-rules.ts
new file mode 100644
index 000000000000..79f7759c7c24
--- /dev/null
+++ b/packages/astro/src/prefetch/speculation-rules.ts
@@ -0,0 +1,24 @@
+/**
+ * Generates static speculation rules JSON using `"source": "document"` with CSS selector matching.
+ * This produces a deterministic payload that can be hashed at build time for CSP compatibility,
+ * unlike the dynamic per-URL `"source": "list"` approach in `appendSpeculationRules()`.
+ */
+export function generateSpeculationRulesContent(prefetchAll: boolean): string {
+	const selector = prefetchAll ? 'a' : 'a[data-astro-prefetch]';
+	return JSON.stringify({
+		prerender: [
+			{
+				source: 'document',
+				where: { selector_matches: selector },
+				eagerness: 'moderate',
+			},
+		],
+		prefetch: [
+			{
+				source: 'document',
+				where: { selector_matches: selector },
+				eagerness: 'moderate',
+			},
+		],
+	});
+}
diff --git a/packages/astro/src/runtime/server/render/head.ts b/packages/astro/src/runtime/server/render/head.ts
index 5aebc7b924d5..9ccfa9aee5fa 100644
--- a/packages/astro/src/runtime/server/render/head.ts
+++ b/packages/astro/src/runtime/server/render/head.ts
@@ -71,6 +71,19 @@ export function renderAllHeadContent(result: SSRResult) {
 	const sep = result.compressHTML === true || result.compressHTML === 'jsx' ? '' : '\n';
 	content += styles.join(sep) + links.join(sep) + scripts.join(sep);
 
+	// Inject static speculation rules when CSP + clientPrerender are both enabled.
+	// The content is pre-hashed at build time and included in the CSP script-src directive.
+	if (result.speculationRulesContent) {
+		content += renderElement(
+			'script',
+			{
+				props: { type: 'speculationrules' },
+				children: result.speculationRulesContent,
+			},
+			false,
+		);
+	}
+
 	content += result._metadata.extraHead.join('');
 
 	return markHTMLString(content);
diff --git a/packages/astro/src/types/public/internal.ts b/packages/astro/src/types/public/internal.ts
index 20c861e0013b..d78b0a3986e4 100644
--- a/packages/astro/src/types/public/internal.ts
+++ b/packages/astro/src/types/public/internal.ts
@@ -252,6 +252,8 @@ export interface SSRResult {
 	isStrictDynamic: SSRManifestCSP['isStrictDynamic'];
 	scriptDirective: SSRManifestCSP['scriptDirective'];
 	styleDirective: SSRManifestCSP['styleDirective'];
+	/** Static speculation rules JSON to inject in the head when CSP + clientPrerender are both enabled. */
+	speculationRulesContent?: string;
 	internalFetchHeaders?: Record<string, string>;
 }
 
diff --git a/packages/astro/test/units/csp/speculation-rules.test.ts b/packages/astro/test/units/csp/speculation-rules.test.ts
new file mode 100644
index 000000000000..3e796f8388cf
--- /dev/null
+++ b/packages/astro/test/units/csp/speculation-rules.test.ts
@@ -0,0 +1,36 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { generateSpeculationRulesContent } from '../../../dist/prefetch/speculation-rules.js';
+import { generateCspDigest } from '../../../dist/core/encryption.js';
+
+describe('speculation rules CSP integration', () => {
+	it('generates document-source speculation rules with data-astro-prefetch selector', () => {
+		const content = generateSpeculationRulesContent(false);
+		const parsed = JSON.parse(content);
+		assert.equal(parsed.prerender[0].source, 'document');
+		assert.equal(parsed.prerender[0].where.selector_matches, 'a[data-astro-prefetch]');
+		assert.equal(parsed.prefetch[0].source, 'document');
+		assert.equal(parsed.prefetch[0].where.selector_matches, 'a[data-astro-prefetch]');
+	});
+
+	it('uses "a" selector when prefetchAll is true', () => {
+		const content = generateSpeculationRulesContent(true);
+		const parsed = JSON.parse(content);
+		assert.equal(parsed.prerender[0].where.selector_matches, 'a');
+		assert.equal(parsed.prefetch[0].where.selector_matches, 'a');
+	});
+
+	it('produces a deterministic hash for CSP', async () => {
+		const content1 = generateSpeculationRulesContent(false);
+		const content2 = generateSpeculationRulesContent(false);
+		assert.equal(content1, content2);
+
+		const hash = await generateCspDigest(content1, 'SHA-256');
+		assert.equal(typeof hash, 'string');
+		assert.ok(hash.length > 0);
+
+		// Same content always produces same hash
+		const hash2 = await generateCspDigest(content2, 'SHA-256');
+		assert.equal(hash, hash2);
+	});
+});

From bd2c1a5a70666cc140c73a77edb41882fc88b277 Mon Sep 17 00:00:00 2001
From: "Houston (Bot)" <108291165+astrobot-houston@users.noreply.github.com>
Date: Fri, 7 Aug 2026 09:06:03 -0700
Subject: [PATCH 5/7] Validate content collection reference() IDs after sync
 (#17582)

* fix(content): validate references after sync to catch invalid entry IDs

Adds post-sync reference validation to the content layer. After all
loaders complete, walks entry data to find reference objects and checks
that referenced entries exist in the store. Logs an error when a
reference points to a non-existent entry.

This restores validation that was lost during the Zod 4 upgrade
(PR #14956), which removed the inline store check from createReference().

Fixes #17322

* Add changeset

---------

Co-authored-by: Matthew Phillips <matthew@matthewphillips.info>
---
 .changeset/hungry-tips-enjoy.md               |   5 +
 packages/astro/src/content/content-layer.ts   |  74 ++++++++++
 .../content-layer/data-transforms.test.ts     | 134 ++++++++++++++++++
 3 files changed, 213 insertions(+)
 create mode 100644 .changeset/hungry-tips-enjoy.md

diff --git a/.changeset/hungry-tips-enjoy.md b/.changeset/hungry-tips-enjoy.md
new file mode 100644
index 000000000000..b11dc9ed180a
--- /dev/null
+++ b/.changeset/hungry-tips-enjoy.md
@@ -0,0 +1,5 @@
+---
+'astro': patch
+---
+
+Fixes a regression where content collection `reference()` fields silently accepted entry IDs that don't exist, such as an ID that doesn't match a loader's slugified version of it. Astro now logs an error for references that point to a missing entry after all loaders finish syncing.
diff --git a/packages/astro/src/content/content-layer.ts b/packages/astro/src/content/content-layer.ts
index 62e13036612b..bab645bfb250 100644
--- a/packages/astro/src/content/content-layer.ts
+++ b/packages/astro/src/content/content-layer.ts
@@ -347,6 +347,7 @@ export class ContentLayer {
 				}
 			}),
 		);
+		this.#validateReferences(contentConfig.config.collections, logger);
 		await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
 		await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
 		const assetImportsFile = new URL(ASSET_IMPORTS_FILE, this.#settings.dotAstroDir);
@@ -360,6 +361,79 @@ export class ContentLayer {
 		}
 	}
 
+	/**
+	 * After all loaders complete, walks every entry's data to find reference objects
+	 * (`{ id, collection }`) and checks that the referenced entry exists in the store.
+	 * This replaces the inline Zod validation that was removed in the Zod 4 upgrade.
+	 */
+	#validateReferences(collections: Record<string, any>, logger: { error(message: string): void }) {
+		const collectionNames = new Set(Object.keys(collections));
+		for (const collectionName of collectionNames) {
+			for (const entry of this.#store.values(collectionName)) {
+				if (entry?.data) {
+					this.#findInvalidReferences(
+						entry.data,
+						collectionNames,
+						collectionName,
+						entry.id,
+						logger,
+						'',
+					);
+				}
+			}
+		}
+	}
+
+	#findInvalidReferences(
+		value: unknown,
+		collectionNames: Set<string>,
+		ownerCollection: string,
+		ownerId: string,
+		logger: { error(message: string): void },
+		path: string,
+	) {
+		if (value == null || typeof value !== 'object') return;
+
+		if (Array.isArray(value)) {
+			for (let i = 0; i < value.length; i++) {
+				this.#findInvalidReferences(
+					value[i],
+					collectionNames,
+					ownerCollection,
+					ownerId,
+					logger,
+					`${path}[${i}]`,
+				);
+			}
+			return;
+		}
+
+		const obj = value as Record<string, unknown>;
+		// A reference object has `id` (or `slug`) and `collection` string fields
+		if (typeof obj.collection === 'string' && collectionNames.has(obj.collection)) {
+			const refId =
+				typeof obj.id === 'string' ? obj.id : typeof obj.slug === 'string' ? obj.slug : undefined;
+			if (refId !== undefined && !this.#store.has(obj.collection, refId)) {
+				const fieldPath = path ? ` (field: ${path})` : '';
+				logger.error(
+					`Invalid content reference: entry "${ownerId}" in collection "${ownerCollection}"${fieldPath} references "${refId}" in collection "${obj.collection}", but that entry does not exist.`,
+				);
+			}
+			return;
+		}
+
+		for (const [key, val] of Object.entries(obj)) {
+			this.#findInvalidReferences(
+				val,
+				collectionNames,
+				ownerCollection,
+				ownerId,
+				logger,
+				path ? `${path}.${key}` : key,
+			);
+		}
+	}
+
 	async regenerateCollectionFileManifest() {
 		const collectionsManifest = new URL(COLLECTIONS_MANIFEST_FILE, this.#settings.dotAstroDir);
 		this.#logger.debug('content', 'Regenerating collection file manifest');
diff --git a/packages/astro/test/units/content-layer/data-transforms.test.ts b/packages/astro/test/units/content-layer/data-transforms.test.ts
index 5aba7cf0eeb8..03f07d2fb024 100644
--- a/packages/astro/test/units/content-layer/data-transforms.test.ts
+++ b/packages/astro/test/units/content-layer/data-transforms.test.ts
@@ -515,6 +515,140 @@ describe('Content Layer - Data Transforms', () => {
 		assert.equal(result2.data.category, 'general');
 	});
 
+	it('logs error for invalid reference after sync', async () => {
+		const store = new MutableDataStore();
+		const settings = createMinimalSettings(root);
+		const errors: string[] = [];
+		const logger = new AstroLogger({
+			destination: {
+				write: (msg: any) => {
+					errors.push(msg.message ?? String(msg));
+				},
+			},
+			level: 'info',
+		});
+
+		const authorsLoader = {
+			name: 'authors-loader',
+			load: async (context: any) => {
+				const parsed = await context.parseData({
+					id: 'john-doe',
+					data: { id: 'john-doe', name: 'John Doe' },
+				});
+				await context.store.set({ id: 'john-doe', data: parsed });
+			},
+		};
+
+		const postsLoader = {
+			name: 'posts-loader',
+			load: async (context: any) => {
+				const parsed = await context.parseData({
+					id: 'my-post',
+					data: { id: 'my-post', title: 'My Post', author: 'John-Doe' },
+				});
+				await context.store.set({ id: 'my-post', data: parsed });
+			},
+		};
+
+		const collections = {
+			authors: defineCollection({
+				loader: authorsLoader,
+				schema: z.object({ id: z.string(), name: z.string() }),
+			}),
+			posts: defineCollection({
+				loader: postsLoader,
+				schema: z.object({
+					id: z.string(),
+					title: z.string(),
+					author: reference('authors'),
+				}),
+			}),
+		};
+
+		const contentLayer = new ContentLayer({
+			settings,
+			logger,
+			store,
+			contentConfigObserver: createTestConfigObserver(collections),
+		});
+
+		await contentLayer.sync();
+
+		// The reference "John-Doe" should trigger an error because the actual id is "john-doe"
+		const errorMessages = errors.join('\n');
+		assert.ok(
+			errorMessages.includes('John-Doe') && errorMessages.includes('does not exist'),
+			`Expected error about invalid reference "John-Doe", got: ${errorMessages}`,
+		);
+	});
+
+	it('does not log error for valid references after sync', async () => {
+		const store = new MutableDataStore();
+		const settings = createMinimalSettings(root);
+		const errors: string[] = [];
+		const logger = new AstroLogger({
+			destination: {
+				write: (msg: any) => {
+					errors.push(msg.message ?? String(msg));
+				},
+			},
+			level: 'info',
+		});
+
+		const authorsLoader = {
+			name: 'authors-loader',
+			load: async (context: any) => {
+				const parsed = await context.parseData({
+					id: 'john-doe',
+					data: { id: 'john-doe', name: 'John Doe' },
+				});
+				await context.store.set({ id: 'john-doe', data: parsed });
+			},
+		};
+
+		const postsLoader = {
+			name: 'posts-loader',
+			load: async (context: any) => {
+				const parsed = await context.parseData({
+					id: 'my-post',
+					data: { id: 'my-post', title: 'My Post', author: 'john-doe' },
+				});
+				await context.store.set({ id: 'my-post', data: parsed });
+			},
+		};
+
+		const collections = {
+			authors: defineCollection({
+				loader: authorsLoader,
+				schema: z.object({ id: z.string(), name: z.string() }),
+			}),
+			posts: defineCollection({
+				loader: postsLoader,
+				schema: z.object({
+					id: z.string(),
+					title: z.string(),
+					author: reference('authors'),
+				}),
+			}),
+		};
+
+		const contentLayer = new ContentLayer({
+			settings,
+			logger,
+			store,
+			contentConfigObserver: createTestConfigObserver(collections),
+		});
+
+		await contentLayer.sync();
+
+		// No errors about invalid references
+		const errorMessages = errors.join('\n');
+		assert.ok(
+			!errorMessages.includes('does not exist'),
+			`Unexpected reference error: ${errorMessages}`,
+		);
+	});
+
 	it('transforms numeric ids to strings', async () => {
 		const store = new MutableDataStore();
 		const settings = createMinimalSettings(root);

From 263063116c8fa36474b255b7d4ecf43a0a55ffe2 Mon Sep 17 00:00:00 2001
From: Lazizbek Ergashev <lazerg2@gmail.com>
Date: Fri, 7 Aug 2026 22:24:42 +0500
Subject: [PATCH 6/7] fix(language-server): restore auto-import code actions
 for Astro components (#17618)

* fix(language-server): restore auto-import code actions for Astro components

* fix(language-server): use RegExp#exec in Astro import rewrite

* fix(language-server): type the diagnostic report in the code action test

* ci(language-tools): pin vscode test to 1.131.0 for macOS arm64

* ci(language-tools): upgrade @vscode/test-electron to fix macOS launch

VS Code 1.110+ removed the Contents/MacOS/Electron compatibility symlink,
so @vscode/test-electron 2.5.2 spawns a nonexistent launcher and fails with
ENOENT on macOS. 3.x resolves the real binary (Code) under Contents/MacOS.
Reverts the 1.131 version pin, which did not help since any 1.110+ build fails.

---------

Co-authored-by: Matthew Phillips <matthew@matthewphillips.info>
---
 .changeset/lucky-icons-repeat.md              |  5 +++
 .../language-server/src/core/utils.ts         | 12 +++++-
 .../src/plugins/typescript/completions.ts     | 17 ++++++++-
 .../src/plugins/typescript/utils.ts           | 14 ++++++-
 .../fixture/src/components/BlogPost.astro     |  1 +
 .../test/typescript/code-actions.test.ts      | 38 +++++++++++++++++++
 .../test/typescript/completions.test.ts       |  6 ++-
 .../language-server/test/units/utils.test.ts  | 29 ++++++++++++++
 packages/language-tools/vscode/package.json   |  2 +-
 pnpm-lock.yaml                                | 18 ++++++++-
 10 files changed, 134 insertions(+), 8 deletions(-)
 create mode 100644 .changeset/lucky-icons-repeat.md
 create mode 100644 packages/language-tools/language-server/test/fixture/src/components/BlogPost.astro
 create mode 100644 packages/language-tools/language-server/test/typescript/code-actions.test.ts

diff --git a/.changeset/lucky-icons-repeat.md b/.changeset/lucky-icons-repeat.md
new file mode 100644
index 000000000000..e65e80308d05
--- /dev/null
+++ b/.changeset/lucky-icons-repeat.md
@@ -0,0 +1,5 @@
+---
+'@astrojs/language-server': patch
+---
+
+Fixes the missing "Add all missing imports" and "Add import from" quick fixes for Astro components
diff --git a/packages/language-tools/language-server/src/core/utils.ts b/packages/language-tools/language-server/src/core/utils.ts
index be8877df9610..df4b3aa857f8 100644
--- a/packages/language-tools/language-server/src/core/utils.ts
+++ b/packages/language-tools/language-server/src/core/utils.ts
@@ -77,7 +77,8 @@ export function patchTSX(code: string, filePath: string) {
 	const basename = Utils.basename(url).slice(0, -Utils.extname(url).length);
 	const isDynamic = basename.startsWith('[') && basename.endsWith(']');
 
-	return code.replace(/\b(\S*)__AstroComponent_/g, (fullMatch, m1: string) => {
+	const componentNames = new Set<string>();
+	const patched = code.replace(/\b(\S*)__AstroComponent_/g, (fullMatch, m1: string) => {
 		// If we don't have a match here, it usually means the file has a weird name that couldn't be expressed with valid identifier characters
 		if (!m1) {
 			if (basename === '404') return 'FourOhFourAstroComponent';
@@ -85,6 +86,15 @@ export function patchTSX(code: string, filePath: string) {
 		}
 
 		const componentName = isDynamic ? `_${m1}_` : m1[0].toUpperCase() + m1.slice(1);
+		componentNames.add(componentName);
 		return `${componentName}AstroComponent`;
 	});
+
+	// TypeScript matches auto-imports against export names, so the suffixed name is never offered for `<Component />`
+	const cleanName = classNameFromFilename(filePath);
+	if (!componentNames.has(cleanName)) {
+		return patched;
+	}
+
+	return `${patched}\nexport { ${cleanName}AstroComponent as ${cleanName} };\n`;
 }
diff --git a/packages/language-tools/language-server/src/plugins/typescript/completions.ts b/packages/language-tools/language-server/src/plugins/typescript/completions.ts
index d52b977ff9d8..230b0f527c24 100644
--- a/packages/language-tools/language-server/src/plugins/typescript/completions.ts
+++ b/packages/language-tools/language-server/src/plugins/typescript/completions.ts
@@ -20,6 +20,7 @@ export function enhancedProvideCompletionItems(
 	documentText: string,
 ): CompletionList {
 	const importedAstroSources = getAlreadyImportedAstroComponentSources(ts, documentText);
+	const seenAstroComponents = new Set<string>();
 
 	completions.items = completions.items
 		.filter((completion) => {
@@ -28,7 +29,21 @@ export function enhancedProvideCompletionItems(
 			}
 
 			const source = completion?.data?.originalItem?.source;
-			return !(source && importedAstroSources.has(source));
+			if (source && importedAstroSources.has(source)) {
+				return false;
+			}
+
+			// A component is exported twice, as a default export and under its clean name, so only offer it once
+			if (isAstroComponentImportSource(source)) {
+				const key = `${stripAstroComponentSuffix(String(completion.label))}\u0000${source}`;
+				if (seenAstroComponents.has(key)) {
+					return false;
+				}
+
+				seenAstroComponents.add(key);
+			}
+
+			return true;
 		})
 		.map((completion) => {
 			const source = completion?.data?.originalItem?.source;
diff --git a/packages/language-tools/language-server/src/plugins/typescript/utils.ts b/packages/language-tools/language-server/src/plugins/typescript/utils.ts
index ba9fcda4f8de..cde2bcdc3dbe 100644
--- a/packages/language-tools/language-server/src/plugins/typescript/utils.ts
+++ b/packages/language-tools/language-server/src/plugins/typescript/utils.ts
@@ -1,5 +1,6 @@
 import type { TextEdit } from 'vscode-html-languageservice';
 import type { AstroVirtualCode } from '../../core/index.js';
+import { classNameFromFilename } from '../../core/utils.js';
 import { editShouldBeInFrontmatter, ensureProperEditForFrontmatter } from '../utils.js';
 
 const ASTRO_COMPONENT_SUFFIX = 'AstroComponent';
@@ -7,6 +8,8 @@ const ASTRO_IMPORT_FROM_PATTERN = /\bfrom\s+['"][^'"]+\.astro['"]/;
 const ASTRO_DEFAULT_IMPORT_PATTERN =
 	/^(\s*import(?:\s+type)?\s+)([A-Za-z_$][\w$]*)AstroComponent(?=\s*,|\s+from\b)/;
 const ASTRO_DEFAULT_ALIAS_PATTERN = /(default\s+as\s+)([A-Za-z_$][\w$]*)AstroComponent(?=\s*\})/;
+const ASTRO_NAMED_IMPORT_PATTERN =
+	/^(\s*import\s+)\{\s*([A-Za-z_$][\w$]*)\s*\}(\s+from\s+['"]([^'"]+\.astro)['"])/;
 
 export function isAstroComponentImportSource(source: string | undefined): source is string {
 	return !!source && source.endsWith('.astro');
@@ -28,13 +31,22 @@ export function rewriteAstroImportText(text: string) {
 				return line;
 			}
 
-			return line
+			return rewriteComponentNamedImport(line)
 				.replace(ASTRO_DEFAULT_IMPORT_PATTERN, '$1$2')
 				.replace(ASTRO_DEFAULT_ALIAS_PATTERN, '$1$2');
 		})
 		.join('\n');
 }
 
+function rewriteComponentNamedImport(line: string) {
+	const match = ASTRO_NAMED_IMPORT_PATTERN.exec(line);
+	if (!match || match[2] !== classNameFromFilename(match[4])) {
+		return line;
+	}
+
+	return line.replace(ASTRO_NAMED_IMPORT_PATTERN, '$1$2$3');
+}
+
 export function getAlreadyImportedAstroComponentSources(
 	ts: typeof import('typescript'),
 	documentText: string,
diff --git a/packages/language-tools/language-server/test/fixture/src/components/BlogPost.astro b/packages/language-tools/language-server/test/fixture/src/components/BlogPost.astro
new file mode 100644
index 000000000000..de999857b5da
--- /dev/null
+++ b/packages/language-tools/language-server/test/fixture/src/components/BlogPost.astro
@@ -0,0 +1 @@
+<article>Blog Post</article>
diff --git a/packages/language-tools/language-server/test/typescript/code-actions.test.ts b/packages/language-tools/language-server/test/typescript/code-actions.test.ts
new file mode 100644
index 000000000000..e297c117947b
--- /dev/null
+++ b/packages/language-tools/language-server/test/typescript/code-actions.test.ts
@@ -0,0 +1,38 @@
+import assert from 'node:assert';
+import { before, describe, it } from 'node:test';
+import { type CodeAction, type FullDocumentDiagnosticReport, Range } from '@volar/language-server';
+import { getLanguageServer, type LanguageServer } from '../server.ts';
+
+describe('TypeScript - Code Actions', () => {
+	let languageServer: LanguageServer;
+
+	before(async () => (languageServer = await getLanguageServer()));
+
+	it('offers to import an Astro component that is used but not imported', async () => {
+		const document = await languageServer.openFakeDocument('---\n---\n\n<BlogPost />\n', 'astro');
+		const diagnostics = (await languageServer.handle.sendDocumentDiagnosticRequest(
+			document.uri,
+		)) as FullDocumentDiagnosticReport;
+		const codeActions = await languageServer.handle.sendCodeActionsRequest(
+			document.uri,
+			Range.create(3, 1, 3, 9),
+			{
+				diagnostics: diagnostics.items,
+				only: ['quickfix'],
+				triggerKind: 1,
+			},
+		);
+
+		const importAction = (codeActions as CodeAction[])?.find((codeAction) =>
+			codeAction.title.startsWith('Add import from'),
+		);
+		assert.ok(importAction);
+
+		const edit = (importAction.edit?.documentChanges?.[0] as { edits: { newText: string }[] })
+			.edits[0];
+		assert.strictEqual(
+			edit.newText.includes('import BlogPost from "./src/components/BlogPost.astro";'),
+			true,
+		);
+	});
+});
diff --git a/packages/language-tools/language-server/test/typescript/completions.test.ts b/packages/language-tools/language-server/test/typescript/completions.test.ts
index cf28eb883a11..acfbc501341c 100644
--- a/packages/language-tools/language-server/test/typescript/completions.test.ts
+++ b/packages/language-tools/language-server/test/typescript/completions.test.ts
@@ -102,11 +102,13 @@ describe('TypeScript - Completions', async () => {
 			Position.create(3, 4),
 		);
 
-		const imageCompletion = completions?.items.find(
+		const imageCompletions = completions?.items.filter(
 			(item) =>
 				item.label === 'Image' && item.labelDetails?.description === '../components/Image.astro',
 		);
-		assert.notStrictEqual(imageCompletion, undefined);
+		assert.strictEqual(imageCompletions?.length, 1);
+
+		const imageCompletion = imageCompletions[0];
 		assert.ok(!imageCompletion?.filterText?.includes('AstroComponent'));
 		assert.ok(!imageCompletion?.insertText?.includes('AstroComponent'));
 
diff --git a/packages/language-tools/language-server/test/units/utils.test.ts b/packages/language-tools/language-server/test/units/utils.test.ts
index 55750f03a3b1..1e010ce47334 100644
--- a/packages/language-tools/language-server/test/units/utils.test.ts
+++ b/packages/language-tools/language-server/test/units/utils.test.ts
@@ -150,6 +150,20 @@ describe('Utilities', async () => {
 		);
 	});
 
+	it('rewriteAstroImportText - turns component named imports into default imports', () => {
+		assert.strictEqual(
+			rewriteAstroImportText(`import { Image } from "../components/Image.astro";\n`),
+			`import Image from "../components/Image.astro";\n`,
+		);
+	});
+
+	it('rewriteAstroImportText - keeps named imports that are not the component itself', () => {
+		assert.strictEqual(
+			rewriteAstroImportText(`import { Props } from "../components/Image.astro";\n`),
+			`import { Props } from "../components/Image.astro";\n`,
+		);
+	});
+
 	it('rewriteAstroImportText - strips AstroComponent suffixes from default aliases', () => {
 		assert.strictEqual(
 			rewriteAstroImportText(
@@ -237,6 +251,21 @@ export default function Image__AstroComponent_(_props: Record<string, any>): any
 		);
 	});
 
+	it('patchTSX - re-exports the component under its clean name', () => {
+		const input = `export default function Image__AstroComponent_(_props: Record<string, any>): any {}`;
+
+		assert.match(
+			patchTSX(input, 'file:///src/components/Image.astro'),
+			/export \{ ImageAstroComponent as Image \};/,
+		);
+	});
+
+	it('patchTSX - does not re-export when the clean name is not a valid tag name', () => {
+		const input = `export default function slug__AstroComponent_(_props: Record<string, any>): any {}`;
+
+		assert.doesNotMatch(patchTSX(input, 'file:///src/pages/[slug].astro'), /^export \{/m);
+	});
+
 	it('addAstroTypes - adds getParsedCommandLine that filters non-TS files', () => {
 		const mockHost = {
 			getScriptFileNames: () => [],
diff --git a/packages/language-tools/vscode/package.json b/packages/language-tools/vscode/package.json
index e92068527a04..a5ae4470be7d 100644
--- a/packages/language-tools/vscode/package.json
+++ b/packages/language-tools/vscode/package.json
@@ -254,7 +254,7 @@
     "@volar/language-server": "~2.4.28",
     "@volar/vscode": "~2.4.28",
     "@vscode/test-cli": "^0.0.12",
-    "@vscode/test-electron": "^2.5.2",
+    "@vscode/test-electron": "^3.1.0",
     "@vscode/vsce": "2.32.0",
     "esbuild": "^0.17.19",
     "esbuild-plugin-copy": "^2.1.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 083b6b51d4ee..e95ef333859a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6895,8 +6895,8 @@ importers:
         specifier: ^0.0.12
         version: 0.0.12
       '@vscode/test-electron':
-        specifier: ^2.5.2
-        version: 2.5.2
+        specifier: ^3.1.0
+        version: 3.1.0
       '@vscode/vsce':
         specifier: 2.32.0
         version: 2.32.0
@@ -10772,6 +10772,10 @@ packages:
     resolution: {integrity: sha512-8ukpxv4wYe0iWMRQU18jhzJOHkeGKbnw7xWRX3Zw1WJA4cEKbHcmmLPdPrPtL6rhDcrlCZN+xKRpv09n4gRHYg==}
     engines: {node: '>=16'}
 
+  '@vscode/test-electron@3.1.0':
+    resolution: {integrity: sha512-CRqv5u+YYoseuNVJ6Tyo4k0sF0mx4qnKMihRB0PjsUF8Dc0WKtCXo6CNL6nWWm5esfFQsQA/pejMj4ZbpJVLTw==}
+    engines: {node: '>=22'}
+
   '@vscode/vsce-sign-alpine-arm64@2.0.6':
     resolution: {integrity: sha512-wKkJBsvKF+f0GfsUuGT0tSW0kZL87QggEiqNqK6/8hvqsXvpx8OsTEc3mnE1kejkh5r+qUyQ7PtF8jZYN0mo8Q==}
     cpu: [arm64]
@@ -20359,6 +20363,16 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@vscode/test-electron@3.1.0':
+    dependencies:
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      jszip: 3.10.1
+      ora: 8.2.0
+      semver: 7.8.5
+    transitivePeerDependencies:
+      - supports-color
+
   '@vscode/vsce-sign-alpine-arm64@2.0.6':
     optional: true
 

From 7c4bf1b0c3d609281082ab196947c7f67e1c1088 Mon Sep 17 00:00:00 2001
From: swaggysnippets <126371507+swaggysnippets@users.noreply.github.com>
Date: Fri, 7 Aug 2026 12:58:14 -0500
Subject: [PATCH 7/7] Add Cloudflare Actions build regression coverage (#17137)

---
 .../cloudflare/test/typegen-phase.test.ts     | 120 ++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 packages/integrations/cloudflare/test/typegen-phase.test.ts

diff --git a/packages/integrations/cloudflare/test/typegen-phase.test.ts b/packages/integrations/cloudflare/test/typegen-phase.test.ts
new file mode 100644
index 000000000000..ba961f2406d3
--- /dev/null
+++ b/packages/integrations/cloudflare/test/typegen-phase.test.ts
@@ -0,0 +1,120 @@
+import * as assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import type { HookParameters } from 'astro';
+import type { Plugin } from 'vite';
+import cloudflare from '../dist/index.js';
+
+// `astro build` and `astro sync` both run type generation (build via its
+// internal sync pass), which creates a temporary Vite server. #16961 made the
+// adapter skip two things on that server: the `configureServer` hook of the
+// Cloudflare Vite plugins (which boots the workerd runtime, see #16332) and
+// dependency discovery (`optimizeDeps.noDiscovery`), so type generation never
+// re-optimizes a dependency cache another environment may be holding on to.
+// These tests pin both effects by invoking `astro:config:setup` directly and
+// asserting the resolved Vite config — no build, no server, deterministic.
+
+interface OptimizeDepsPatch {
+	optimizeDeps?: { noDiscovery?: boolean; include?: string[]; exclude?: string[] };
+}
+
+async function runConfigSetup(command: 'dev' | 'build' | 'sync') {
+	const integration = cloudflare();
+	let updatedConfig: { vite: { plugins: unknown[] } } | undefined;
+
+	const context = {
+		command,
+		config: {
+			root: new URL('./', import.meta.url),
+			srcDir: new URL('./src/', import.meta.url),
+			base: '/',
+			build: { assets: '_astro' },
+			experimental: {},
+			vite: {},
+			image: {},
+		},
+		updateConfig(config: { vite: { plugins: unknown[] } }) {
+			updatedConfig = config;
+		},
+		logger: { info() {}, warn() {}, error() {}, debug() {} },
+		addWatchFile() {},
+	};
+
+	await integration.hooks['astro:config:setup']?.(
+		context as unknown as HookParameters<'astro:config:setup'>,
+	);
+	assert.ok(updatedConfig, 'expected the adapter to call updateConfig()');
+
+	const plugins = updatedConfig.vite.plugins;
+	// `cfVitePlugin()` returns an array of plugins that the adapter passes
+	// through as a single nested entry; every adapter-authored plugin is flat.
+	const cloudflareVitePlugins = plugins.find(Array.isArray) as Plugin[] | undefined;
+	assert.ok(
+		cloudflareVitePlugins?.length,
+		'expected the resolved Vite config to contain the Cloudflare Vite plugins',
+	);
+
+	const environmentPlugin = plugins
+		.flat()
+		.find((plugin) => (plugin as Plugin)?.name === '@astrojs/cloudflare:environment') as
+		| Plugin
+		| undefined;
+	assert.ok(environmentPlugin, 'expected the @astrojs/cloudflare:environment plugin');
+	const configEnvironment = environmentPlugin.configEnvironment as unknown as (
+		environmentName: string,
+		options: Record<string, unknown>,
+	) => OptimizeDepsPatch | undefined;
+
+	return { cloudflareVitePlugins, configEnvironment };
+}
+
+describe('type generation phase (build and sync)', () => {
+	for (const command of ['build', 'sync'] as const) {
+		describe(`command: ${command}`, () => {
+			it('drops configureServer so type generation does not boot workerd', async () => {
+				const { cloudflareVitePlugins } = await runConfigSetup(command);
+				for (const plugin of cloudflareVitePlugins) {
+					assert.equal(
+						plugin.configureServer,
+						undefined,
+						`expected configureServer to be removed from "${plugin.name}"`,
+					);
+				}
+			});
+
+			it('disables dependency discovery for every Vite environment', async () => {
+				const { configEnvironment } = await runConfigSetup(command);
+				for (const environmentName of ['client', 'ssr', 'astro', 'prerender']) {
+					assert.deepEqual(
+						configEnvironment(environmentName, {}),
+						{ optimizeDeps: { noDiscovery: true, include: [] } },
+						`expected dependency discovery to be disabled for the "${environmentName}" environment`,
+					);
+				}
+			});
+		});
+	}
+
+	// The dev command exercises the same code paths with the guard off, proving
+	// the assertions above discriminate: reverting the `isTypeGenPhase` guard
+	// makes build/sync produce this dev-shaped config and fail the tests above.
+	describe('command: dev', () => {
+		it('keeps configureServer so the dev server boots the workerd runtime', async () => {
+			const { cloudflareVitePlugins } = await runConfigSetup('dev');
+			assert.ok(
+				cloudflareVitePlugins.some((plugin) => plugin.configureServer != null),
+				'expected at least one Cloudflare Vite plugin to register configureServer',
+			);
+		});
+
+		it('keeps dependency discovery and prebundles the Actions server entrypoints', async () => {
+			const { configEnvironment } = await runConfigSetup('dev');
+			const result = configEnvironment('ssr', {});
+			assert.notEqual(result?.optimizeDeps?.noDiscovery, true);
+			const include = result?.optimizeDeps?.include ?? [];
+			// Actions projects hit the server runtime through these prebundled
+			// entrypoints (#16933); losing them reintroduces mid-request discovery.
+			assert.ok(include.includes('astro/actions/runtime/entrypoints/server.js'));
+			assert.ok(include.includes('astro/actions/runtime/entrypoints/route.js'));
+		});
+	});
+});