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/.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/.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/.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/.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/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>
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/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/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);
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);
+	});
+});
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": {
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'));
+		});
+	});
+});
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/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 {
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