From c411200d0b6f45c3fa6f5ce626f3538e981db653 Mon Sep 17 00:00:00 2001
From: Matthew Phillips <matthewphillips@cloudflare.com>
Date: Tue, 30 Jun 2026 11:20:31 -0400
Subject: [PATCH 1/7] Pre-bundle Cloudflare worker server entrypoint in dev
 (#17236)

* Pre-bundle Cloudflare worker server entrypoint in dev

* Apply suggestion from @matthewp
---
 .changeset/cloudflare-prebundle-server-entry.md | 5 +++++
 packages/integrations/cloudflare/src/index.ts   | 1 +
 2 files changed, 6 insertions(+)
 create mode 100644 .changeset/cloudflare-prebundle-server-entry.md

diff --git a/.changeset/cloudflare-prebundle-server-entry.md b/.changeset/cloudflare-prebundle-server-entry.md
new file mode 100644
index 000000000000..b880fc2189e4
--- /dev/null
+++ b/.changeset/cloudflare-prebundle-server-entry.md
@@ -0,0 +1,5 @@
+---
+'@astrojs/cloudflare': patch
+---
+
+Prevents warnings in the Cloudflare adapter about optimizing the `@astrojs/cloudflare/entrypoints/server` module in dev.
diff --git a/packages/integrations/cloudflare/src/index.ts b/packages/integrations/cloudflare/src/index.ts
index 96399acc5f17..fdf88adea275 100644
--- a/packages/integrations/cloudflare/src/index.ts
+++ b/packages/integrations/cloudflare/src/index.ts
@@ -302,6 +302,7 @@ export default function createIntegration({
 											optimizeDeps: {
 												include: [
 													'@astrojs/cloudflare/image-service-workerd',
+													'@astrojs/cloudflare/entrypoints/server',
 													'astro',
 													'astro/runtime/**',
 													'astro > html-escaper',

From 257505ebfd8be87e6b11fd369340245edd0c937a Mon Sep 17 00:00:00 2001
From: Matthew Phillips <matthewphillips@cloudflare.com>
Date: Tue, 30 Jun 2026 11:57:36 -0400
Subject: [PATCH 2/7] Fix styles dropped when an await precedes a propagating
 component in slot markup (#17232)

* Fix styles dropped when await precedes a propagating component in slot markup

Gates async slot pre-render awaiting on routes that use head propagation
and discovers propagators via a fixpoint loop, so propagating components
behind an await in slot markup are collected without blocking the head on
unrelated markup awaits.

Closes #17218

* Clarify head-collection loop comments from review
---
 .changeset/proud-pugs-jump.md                 |  5 ++
 packages/astro/src/core/fetch/fetch-state.ts  |  2 +
 .../astro/src/core/head-propagation/buffer.ts | 56 +++++++++++++++----
 .../runtime/server/render/astro/instance.ts   |  9 +++
 .../astro/src/runtime/server/render/page.ts   | 14 +++--
 packages/astro/src/types/public/internal.ts   | 14 +++++
 .../astro/test/content-collections.test.ts    | 20 +++++++
 .../src/components/SlotLayout.astro           | 11 ++++
 .../src/pages/async-slot.astro                | 15 +++++
 .../render/head-propagation/buffer.test.ts    | 51 ++++++++++++++++-
 .../server-islands-render.test.ts             |  2 +
 11 files changed, 181 insertions(+), 18 deletions(-)
 create mode 100644 .changeset/proud-pugs-jump.md
 create mode 100644 packages/astro/test/fixtures/content-collections-base/src/components/SlotLayout.astro
 create mode 100644 packages/astro/test/fixtures/content-collections-base/src/pages/async-slot.astro

diff --git a/.changeset/proud-pugs-jump.md b/.changeset/proud-pugs-jump.md
new file mode 100644
index 000000000000..11c796ee19ba
--- /dev/null
+++ b/.changeset/proud-pugs-jump.md
@@ -0,0 +1,5 @@
+---
+'astro': patch
+---
+
+Fixes a bug where `<style>` tags from components such as a content collection's `Content` could be silently dropped from the output when an `await` appeared before the component in an `.astro` file's markup.
diff --git a/packages/astro/src/core/fetch/fetch-state.ts b/packages/astro/src/core/fetch/fetch-state.ts
index b0dc5b79163d..2e7ac3cac222 100644
--- a/packages/astro/src/core/fetch/fetch-state.ts
+++ b/packages/astro/src/core/fetch/fetch-state.ts
@@ -419,6 +419,8 @@ export class FetchState implements AstroFetchState {
 				extraStyleHashes,
 				extraScriptHashes,
 				propagators: new Set(),
+				routeHasPropagation: false,
+				pendingSlotEvaluations: [],
 				templateDepth: 0,
 			},
 			cspDestination: manifest.csp?.cspDestination ?? (routeData.prerender ? 'meta' : 'header'),
diff --git a/packages/astro/src/core/head-propagation/buffer.ts b/packages/astro/src/core/head-propagation/buffer.ts
index 2e46589a8afe..547614f417a2 100644
--- a/packages/astro/src/core/head-propagation/buffer.ts
+++ b/packages/astro/src/core/head-propagation/buffer.ts
@@ -5,10 +5,21 @@ export interface HeadPropagator {
 }
 
 /**
- * Runs all registered propagators and collects emitted head HTML strings.
+ * Runs all registered propagators and collects the head HTML they emit.
  *
- * This iterates the live `Set`, so propagators discovered during iteration
- * are also processed in the same pass.
+ * Components with head content are discovered as we go. Initializing one
+ * propagator can register more of them: a component marked `in-tree` renders
+ * its children, and one of those children may be a `self` component that emits
+ * styles. Slots add a second way to find them — a slot whose markup contains an
+ * `await` only reaches the components after that `await` once it resolves, so
+ * we also wait for those pending slot pre-renders. We keep initializing
+ * propagators and waiting on slots until no new ones appear.
+ *
+ * Propagators are tracked in a `seen` set rather than read through a single
+ * live `Set` iterator. A propagator can be registered after we have already
+ * iterated to the end of the set (e.g. once a slot's `await` resolves), and a
+ * `Set` iterator that has reported `done` would never report those late
+ * additions.
  *
  * @example
  * If a layout initializes and discovers a nested component that also emits
@@ -20,20 +31,41 @@ export async function collectPropagatedHeadParts(input: {
 	isHeadAndContent: (value: unknown) => value is { head: string };
 }): Promise<string[]> {
 	const collectedHeadParts: string[] = [];
+	const seen = new Set<HeadPropagator>();
+	// Populated (only on propagation routes) by eager async slot pre-renders.
+	const pendingSlotEvaluations = input.result._metadata?.pendingSlotEvaluations ?? [];
 
-	// Keep the iterator live so newly-added propagators are seen.
-	const iterator = input.propagators.values();
 	while (true) {
-		const { value, done } = iterator.next();
-		if (done) {
-			break;
+		// 1. Drain async slot pre-renders first. Resolving them runs the slot
+		//    markup past its `await`s, registering any propagators inside.
+		if (pendingSlotEvaluations.length > 0) {
+			const batch = pendingSlotEvaluations.splice(0, pendingSlotEvaluations.length);
+			await Promise.all(batch);
+			continue;
 		}
 
-		const returnValue = await value.init(input.result);
-		// Only collect explicit head-bearing return values.
-		if (input.isHeadAndContent(returnValue) && returnValue.head) {
-			collectedHeadParts.push(returnValue.head);
+		// 2. Initialize the next not-yet-seen propagator. `init()` may register
+		//    further propagators or queue more slot evaluations.
+		let progressed = false;
+		for (const propagator of input.propagators) {
+			if (seen.has(propagator)) continue;
+			seen.add(propagator);
+			progressed = true;
+
+			const returnValue = await propagator.init(input.result);
+			// Only collect explicit head-bearing return values.
+			if (input.isHeadAndContent(returnValue) && returnValue.head) {
+				collectedHeadParts.push(returnValue.head);
+			}
+			// Only initialize one propagator per `for` pass, then break back to
+			// the `while`. This is not the same as letting the `for` run to its
+			// end: `init()` above may have queued new slot pre-renders, and
+			// breaking returns to step 1 so those are drained before the next
+			// propagator is initialized.
+			break;
 		}
+
+		if (!progressed) break;
 	}
 
 	return collectedHeadParts;
diff --git a/packages/astro/src/runtime/server/render/astro/instance.ts b/packages/astro/src/runtime/server/render/astro/instance.ts
index a47dffe08b0a..76ff5f81a9bf 100644
--- a/packages/astro/src/runtime/server/render/astro/instance.ts
+++ b/packages/astro/src/runtime/server/render/astro/instance.ts
@@ -33,6 +33,15 @@ export class AstroComponentInstance {
 			// prerender the slots eagerly to make collection entries propagate styles and scripts
 			let didRender = false;
 			let value = slots[name](result);
+			// When a slot is async (contains `await` in its markup), the eager
+			// pre-render above only runs up to the first `await`, so any propagating
+			// component sequenced after it (e.g. a content collection `Content` with
+			// styles) is not registered yet. On propagation routes, track the pending
+			// pre-render so head buffering can await it and discover those propagators
+			// before flushing the head. See `collectPropagatedHeadParts`.
+			if (result._metadata.routeHasPropagation && isPromise(value)) {
+				result._metadata.pendingSlotEvaluations.push(value);
+			}
 			this.slotValues[name] = () => {
 				// use prerendered value only once
 				if (!didRender) {
diff --git a/packages/astro/src/runtime/server/render/page.ts b/packages/astro/src/runtime/server/render/page.ts
index 0ad3146b1ba6..07a96e7d7bb6 100644
--- a/packages/astro/src/runtime/server/render/page.ts
+++ b/packages/astro/src/runtime/server/render/page.ts
@@ -1,5 +1,6 @@
 import type { RouteData, SSRResult } from '../../../types/public/internal.js';
 import { isRoute404, isRoute500 } from '../../../core/routing/internal/route-errors.js';
+import { isPropagatingHint } from '../../../core/head-propagation/resolver.js';
 import { renderToAsyncIterable, renderToReadableStream, renderToString } from './astro/render.js';
 import { encoder } from './common.js';
 import { type NonAstroPageComponent, renderComponentToString } from './component.js';
@@ -17,8 +18,9 @@ export async function renderPage(
 	route?: RouteData,
 ): Promise<Response> {
 	if (!isAstroComponentFactory(componentFactory)) {
-		result._metadata.headInTree =
-			result.componentMetadata.get((componentFactory as any).moduleId)?.containsHead ?? false;
+		const nonAstroMeta = result.componentMetadata.get((componentFactory as any).moduleId);
+		result._metadata.headInTree = nonAstroMeta?.containsHead ?? false;
+		result._metadata.routeHasPropagation = isPropagatingHint(nonAstroMeta?.propagation ?? 'none');
 
 		const pageProps: Record<string, any> = { ...(props ?? {}), 'server:root': true };
 
@@ -58,8 +60,12 @@ export async function renderPage(
 
 	// Mark if this page component contains a <head> within its tree. If it does
 	// We avoid implicit head injection entirely.
-	result._metadata.headInTree =
-		result.componentMetadata.get(componentFactory.moduleId!)?.containsHead ?? false;
+	const pageMeta = result.componentMetadata.get(componentFactory.moduleId!);
+	result._metadata.headInTree = pageMeta?.containsHead ?? false;
+	// Only routes on a propagation path need to await async slot pre-renders
+	// before flushing the head (see `collectPropagatedHeadParts`). Other routes
+	// keep streaming without blocking the head on unrelated markup `await`s.
+	result._metadata.routeHasPropagation = isPropagatingHint(pageMeta?.propagation ?? 'none');
 
 	let body: BodyInit | Response;
 	if (streaming) {
diff --git a/packages/astro/src/types/public/internal.ts b/packages/astro/src/types/public/internal.ts
index c9a0c500f471..186e12fff511 100644
--- a/packages/astro/src/types/public/internal.ts
+++ b/packages/astro/src/types/public/internal.ts
@@ -304,6 +304,20 @@ export interface SSRMetadata {
 	extraStyleHashes: string[];
 	extraScriptHashes: string[];
 	propagators: Set<AstroComponentInstance | ServerIslandComponent>;
+	/**
+	 * `true` when the page being rendered is on a head-propagation path (its
+	 * component metadata hint is `in-tree`/`self`). Only then do we await async
+	 * slot pre-renders before collecting head content, so that propagating
+	 * components hidden behind an `await` in slot markup are discovered in time.
+	 * Pages with no propagation keep streaming without paying that cost.
+	 */
+	routeHasPropagation: boolean;
+	/**
+	 * Promises from async slot pre-renders that may still need to register
+	 * propagating components. Drained by `collectPropagatedHeadParts` before
+	 * head content is flushed. Only populated when `routeHasPropagation` is true.
+	 */
+	pendingSlotEvaluations: Promise<unknown>[];
 	/**
 	 * Tracks nesting depth of HTML `<template>` elements during rendering.
 	 * Scripts rendered inside `<template>` tags should not be deduplicated,
diff --git a/packages/astro/test/content-collections.test.ts b/packages/astro/test/content-collections.test.ts
index 38ff8ebca498..2990e0e9abfd 100644
--- a/packages/astro/test/content-collections.test.ts
+++ b/packages/astro/test/content-collections.test.ts
@@ -404,6 +404,26 @@ describe('Content Collections', () => {
 			const $ = cheerio.load(html);
 			assert.equal($('script').attr('src')!.startsWith('/docs'), true);
 		});
+
+		// Regression test for https://github.com/withastro/astro/issues/17218
+		// An `await` in the slot markup before <Content /> used to defer the
+		// propagating component's registration past head buffering, silently
+		// dropping its styles from the build output.
+		it('keeps propagated styles when an await precedes <Content /> in slot markup', async () => {
+			const html = await fixture.readFile('/async-slot/index.html');
+			const $ = cheerio.load(html);
+			const href = $('head link[rel="stylesheet"]').attr('href');
+			assert.ok(href, 'Expected the propagated stylesheet link to survive in the head');
+
+			// Read the emitted CSS (href is base-prefixed with `/docs`) and confirm
+			// it contains the content component's rule.
+			const css = await fixture.readFile(href.replace(/^\/docs/, ''));
+			assert.equal(
+				css.includes('color:'),
+				true,
+				'Expected the style from the content component to be present',
+			);
+		});
 	});
 
 	describe('Mutation', () => {
diff --git a/packages/astro/test/fixtures/content-collections-base/src/components/SlotLayout.astro b/packages/astro/test/fixtures/content-collections-base/src/components/SlotLayout.astro
new file mode 100644
index 000000000000..e80ebc4e91b5
--- /dev/null
+++ b/packages/astro/test/fixtures/content-collections-base/src/components/SlotLayout.astro
@@ -0,0 +1,11 @@
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Async slot</title>
+  </head>
+  <body>
+    <main>
+      <slot />
+    </main>
+  </body>
+</html>
diff --git a/packages/astro/test/fixtures/content-collections-base/src/pages/async-slot.astro b/packages/astro/test/fixtures/content-collections-base/src/pages/async-slot.astro
new file mode 100644
index 000000000000..b46407cc9a69
--- /dev/null
+++ b/packages/astro/test/fixtures/content-collections-base/src/pages/async-slot.astro
@@ -0,0 +1,15 @@
+---
+import { getEntry, render } from 'astro:content';
+import SlotLayout from '../components/SlotLayout.astro';
+const entry = await getEntry('docs', 'one');
+const { Content } = await render(entry);
+---
+<SlotLayout>
+  <!--
+    Regression for #17218: an `await` in the slot markup before <Content />
+    used to defer the propagating component's registration past head buffering,
+    silently dropping its styles.
+  -->
+  <p>{await new Promise((resolve) => setTimeout(() => resolve('ready'), 50))}</p>
+  <Content />
+</SlotLayout>
diff --git a/packages/astro/test/units/render/head-propagation/buffer.test.ts b/packages/astro/test/units/render/head-propagation/buffer.test.ts
index 6d1807b0ff0a..df64aee236aa 100644
--- a/packages/astro/test/units/render/head-propagation/buffer.test.ts
+++ b/packages/astro/test/units/render/head-propagation/buffer.test.ts
@@ -17,8 +17,12 @@ function isHeadAndContent(value: unknown): value is { head: string } {
 	return typeof value === 'object' && value !== null && headAndContentSym in value;
 }
 
-function createResult(): SSRResult {
-	return {} as SSRResult;
+function createResult(pendingSlotEvaluations: Promise<unknown>[] = []): SSRResult {
+	return { _metadata: { pendingSlotEvaluations } } as unknown as SSRResult;
+}
+
+function tick(): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, 0));
 }
 
 describe('head propagation buffer', () => {
@@ -89,4 +93,47 @@ describe('head propagation buffer', () => {
 			'<link rel="stylesheet" href="/late.css">',
 		]);
 	});
+
+	it('drains async slot pre-renders that register propagators after an await', async () => {
+		const propagators = new Set<HeadPropagator>();
+		// Mimics an async slot whose markup registers a propagating component
+		// (e.g. content `Content` with styles) only after an `await` resolves.
+		const slotEvaluation = tick().then(() => {
+			propagators.add({
+				init: () => createHeadAndContentLike('<style>.from-async-slot{color:red}</style>'),
+			});
+		});
+
+		const result = createResult([slotEvaluation]);
+		const collected = await collectPropagatedHeadParts({ propagators, result, isHeadAndContent });
+
+		assert.deepEqual(collected, ['<style>.from-async-slot{color:red}</style>']);
+		// The queue is fully drained.
+		assert.equal(result._metadata.pendingSlotEvaluations.length, 0);
+	});
+
+	it('drains nested async slot pre-renders queued while collecting', async () => {
+		const propagators = new Set<HeadPropagator>();
+		const result = createResult();
+
+		// Outer async slot resolves, registers a propagator AND queues a deeper
+		// async slot pre-render — the case a one-shot `Promise.all` would miss.
+		const outer = tick().then(() => {
+			propagators.add({
+				init: () => createHeadAndContentLike('<style>.outer{}</style>'),
+			});
+			const inner = tick().then(() => {
+				propagators.add({
+					init: () => createHeadAndContentLike('<style>.inner{}</style>'),
+				});
+			});
+			result._metadata.pendingSlotEvaluations.push(inner);
+		});
+		result._metadata.pendingSlotEvaluations.push(outer);
+
+		const collected = await collectPropagatedHeadParts({ propagators, result, isHeadAndContent });
+
+		assert.deepEqual(collected, ['<style>.outer{}</style>', '<style>.inner{}</style>']);
+		assert.equal(result._metadata.pendingSlotEvaluations.length, 0);
+	});
 });
diff --git a/packages/astro/test/units/server-islands/server-islands-render.test.ts b/packages/astro/test/units/server-islands/server-islands-render.test.ts
index f0e0d8093017..aa62183c8f50 100644
--- a/packages/astro/test/units/server-islands/server-islands-render.test.ts
+++ b/packages/astro/test/units/server-islands/server-islands-render.test.ts
@@ -65,6 +65,8 @@ async function createStubResult(overrides: Partial<SSRResult> = {}): Promise<SSR
 			extraStyleHashes: [],
 			extraScriptHashes: [],
 			propagators: new Set(),
+			routeHasPropagation: false,
+			pendingSlotEvaluations: [],
 			templateDepth: 0,
 		},
 		cspDestination: 'header',

From c6d254dab889f9b15ec79eab84d8dbf7f7cd0007 Mon Sep 17 00:00:00 2001
From: Matthew Phillips <matthewphillips@cloudflare.com>
Date: Tue, 30 Jun 2026 13:37:32 -0400
Subject: [PATCH 3/7] Use Vite tsconfig path resolution by default (#17202)

* Resolve tsconfig aliases in Astro style preprocessing

Fixes: #17163
Related: 3cf76c035eef5954637e78015be9c20d0129599a, 4766f3716d1e8ee47902bfdf87963a215c462cbe

Goal: restore Astro 6-style tsconfig alias handling for CSS references that are written inside .astro <style> blocks and therefore go through Astro's direct preprocessCSS() path instead of Vite's normal transform pipeline.

Issue #17163 reported that the earlier CSS alias repair still missed @import url("@/...") and Tailwind-style @reference declarations in component styles. The issue discussion later added @config. Testing resolve.tsconfigPaths showed it is not a replacement here: with Vite 8.1.0/Rolldown 1.1.2 it fails existing Astro alias tests on its own, and even when combined with Astro's custom alias plugin it does not fix the <style> preprocessCSS() path.

Decision: keep Astro's existing config alias plugin, extract its CSS alias rewriting into resolveCssAliases(), and call that same helper from createStylePreprocessor before preprocessCSS(). This preserves the standalone .css transform behavior while covering the compiler preprocessing path that previously bypassed the transform hook.

The helper now matches @import, @reference, and @config path-bearing at-rules, plus the existing quoted url() handling. It resolves only aliases that map to existing files, matching the previous best-effort behavior.

Testing: added an alias-path-alias-style fixture page with @import url('@/styles/base.css'), @reference '@/styles/reference.css', and @config '@/tailwind.config.ts' inside a component <style>. The test asserts the imported CSS is bundled and no @/ alias remains in output CSS.

Verification run:
- pnpm -C packages/astro run build:ci
- pnpm -C packages/astro exec tsc -b
- pnpm -C packages/astro exec astro-scripts test "test/{alias-tsconfig,alias-tsconfig-no-baseurl,alias-path-alias-style,alias-css-url}.test.ts"
- pnpm format

* Enable native tsconfig path resolution

Related: bdeee808c0

Enable Vite's resolve.tsconfigPaths by default so Astro uses the native resolver where it works.

Keep the existing custom config alias plugin as a deprecated fallback because testing showed resolve.tsconfigPaths alone does not pass Astro's existing alias suite with the current Vite/Rolldown stack. The fallback comments now explicitly document supported cases:
- standalone CSS: @import, @reference, @config, and quoted url() references
- Astro <style> preprocessing: the same supported CSS references before preprocessCSS()
- module imports: JS/TS/Astro specifiers via resolveId

The comments also state the fallback is deprecated and should be removed in a future Astro version once Vite covers these paths.

Verification run:
- pnpm format
- pnpm -C packages/astro run build:ci
- pnpm -C packages/astro exec tsc -b
- pnpm -C packages/astro exec astro-scripts test "test/{alias-tsconfig,alias-tsconfig-no-baseurl,alias-path-alias-style,alias-css-url}.test.ts"

* Update changeset for native tsconfig paths

* Narrow tsconfig path fallback changes

Remove the new #17163 regression fixture and the style-preprocessor alias rewrite. The PR is intentionally minimal now: enable Vite's resolve.tsconfigPaths and keep Astro's existing custom alias plugin only as a deprecated fallback for the cases it already supports.

The fallback comments now document the supported CSS cases explicitly without claiming broader @reference/@config support.

Verification run:
- pnpm format
- pnpm -C packages/astro run build:ci
- pnpm -C packages/astro exec tsc -b
- pnpm -C packages/astro exec astro-scripts test "test/{alias-tsconfig,alias-tsconfig-no-baseurl,alias-path-alias-style,alias-css-url}.test.ts"

* Clarify deprecated alias fallback scope

Use an @deprecated JSDoc tag on the custom tsconfig alias fallback and make the supported syntax explicit.

The comments now state that the fallback only covers the already-supported CSS syntax (@import string, @import url(), and quoted url()) plus JS/TS/Astro module specifiers. They also explicitly tell future maintainers and agents not to expand this plugin for @use, @forward, @reference, @config, unquoted url(), or other file-reference syntax.

Verification run:
- pnpm format
- pnpm -C packages/astro run build:ci
- pnpm -C packages/astro exec tsc -b
- pnpm -C packages/astro exec astro-scripts test "test/{alias-tsconfig,alias-tsconfig-no-baseurl,alias-path-alias-style,alias-css-url}.test.ts"

* Address review feedback on alias resolution
---
 .changeset/cuddly-games-sleep.md              |  7 ++++
 packages/astro/src/core/create-vite.ts        |  2 ++
 .../src/vite-plugin-config-alias/index.ts     | 33 ++++++++++++++-----
 3 files changed, 34 insertions(+), 8 deletions(-)
 create mode 100644 .changeset/cuddly-games-sleep.md

diff --git a/.changeset/cuddly-games-sleep.md b/.changeset/cuddly-games-sleep.md
new file mode 100644
index 000000000000..7a5c188cd2ad
--- /dev/null
+++ b/.changeset/cuddly-games-sleep.md
@@ -0,0 +1,7 @@
+---
+'astro': patch
+---
+
+Refactors path alias resolution to use Vite's native `tsconfigPaths` option
+
+This is an internal change with no expected impact on user projects. Astro now defers tsconfig and jsconfig `paths` alias resolution to Vite, keeping a small fallback for a few CSS cases Vite does not yet handle.
diff --git a/packages/astro/src/core/create-vite.ts b/packages/astro/src/core/create-vite.ts
index 0250fdb68e06..0e11ad6f3a79 100644
--- a/packages/astro/src/core/create-vite.ts
+++ b/packages/astro/src/core/create-vite.ts
@@ -250,6 +250,8 @@ export async function createVite(
 			},
 		},
 		resolve: {
+			// Vite's native tsconfig path resolution; see configAliasVitePlugin for the deprecated fallback.
+			tsconfigPaths: true,
 			alias: [
 				{
 					// This is needed for Deno compatibility, as the non-browser version
diff --git a/packages/astro/src/vite-plugin-config-alias/index.ts b/packages/astro/src/vite-plugin-config-alias/index.ts
index dd1c30aa7e14..bd7a8e367102 100644
--- a/packages/astro/src/vite-plugin-config-alias/index.ts
+++ b/packages/astro/src/vite-plugin-config-alias/index.ts
@@ -96,7 +96,25 @@ const cssImportRE = /@import\s+(?:url\(\s*)?['"]([^'"]+)['"]\s*\)?/g;
  */
 const cssUrlRE = /(?<!@import\s+)url\(\s*['"]([^'"]+)['"]\s*\)/g;
 
-/** Returns Vite plugins used to alias paths from tsconfig.json and jsconfig.json. */
+/**
+ * Fallback for tsconfig path aliases that Vite's `resolve.tsconfigPaths` does
+ * not currently handle in Astro's pipeline.
+ *
+ * This plugin is intentionally limited to the syntax Astro already supported
+ * before enabling `resolve.tsconfigPaths`:
+ * - CSS: `@import "..."`
+ * - CSS: `@import url("...")`
+ * - CSS: quoted `url("...")` references
+ * - Modules: JS, TS, and Astro import specifiers handled by `resolveId`
+ *
+ * Do not expand this fallback to new CSS at-rules or preprocessor syntax. It
+ * does not support `@use`, `@forward`, `@reference`, `@config`, unquoted
+ * `url(...)`, or every place a CSS tool might accept a file path. Those should
+ * be handled by Vite's native resolver instead.
+ *
+ * @deprecated This fallback will be removed in a future Astro version once Vite
+ * handles these remaining alias paths.
+ */
 export default function configAliasVitePlugin({
 	settings,
 }: {
@@ -106,10 +124,10 @@ export default function configAliasVitePlugin({
 	if (!configAlias) return null;
 
 	return [
-		// Pre-plugin: rewrite CSS @import aliases to absolute paths before Vite's CSS plugin.
-		// Vite's internal CSS @import resolver (postcss-import) uses a mini plugin container
-		// that doesn't include user resolveId hooks, so we must rewrite aliases in a transform
-		// hook that runs before Vite's CSS processing.
+		// Deprecated CSS fallback for Vite's transform pipeline. Only supports
+		// `@import "..."`, `@import url("...")`, and quoted `url("...")`.
+		// Do not add support here for `@use`, `@forward`, `@reference`, `@config`,
+		// or other CSS/preprocessor file-reference syntax.
 		{
 			name: 'astro:tsconfig-alias-css',
 			enforce: 'pre',
@@ -135,12 +153,10 @@ export default function configAliasVitePlugin({
 
 					let result = code;
 
-					// Rewrite @import aliases
 					if (result.includes('@import')) {
 						result = result.replace(cssImportRE, replaceAliases);
 					}
 
-					// Rewrite url() aliases
 					if (result.includes('url(')) {
 						result = result.replace(cssUrlRE, replaceAliases);
 					}
@@ -151,7 +167,8 @@ export default function configAliasVitePlugin({
 				},
 			},
 		},
-		// Post-plugin: resolve JS/TS imports using tsconfig path aliases via resolveId.
+		// Deprecated module fallback for JS, TS, and Astro import specifiers that
+		// Vite's native tsconfig path resolution does not currently resolve.
 		{
 			name: 'astro:tsconfig-alias',
 			// use post to only resolve ids that all other plugins before it can't

From a7352fda1218bf48d8483a9893c6f7ed9bdf2060 Mon Sep 17 00:00:00 2001
From: Jan Kubica <jankubica@protonmail.com>
Date: Tue, 30 Jun 2026 19:37:55 +0200
Subject: [PATCH 4/7] fix: background dev server fails to start in hoisted
 monorepos (#17193)

Co-authored-by: Matthew Phillips <matthewphillips@cloudflare.com>
---
 .changeset/spawn-background-dev-monorepo.md |  5 +++++
 packages/astro/src/cli/dev/background.ts    | 11 +++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/spawn-background-dev-monorepo.md

diff --git a/.changeset/spawn-background-dev-monorepo.md b/.changeset/spawn-background-dev-monorepo.md
new file mode 100644
index 000000000000..09e4dd48e705
--- /dev/null
+++ b/.changeset/spawn-background-dev-monorepo.md
@@ -0,0 +1,5 @@
+---
+'astro': patch
+---
+
+Fixes the background dev server failing to start when `astro` is hoisted outside the project's `node_modules` (for example bun workspaces). The background process is now spawned from Astro's own resolved location instead of a path assumed under the project root.
diff --git a/packages/astro/src/cli/dev/background.ts b/packages/astro/src/cli/dev/background.ts
index 2a277d526551..6b1104f5719b 100644
--- a/packages/astro/src/cli/dev/background.ts
+++ b/packages/astro/src/cli/dev/background.ts
@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, openSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import type { AstroLogger } from '../../core/logger/core.js';
 import type { Flags } from '../flags.js';
@@ -15,6 +16,8 @@ import {
 } from '../../core/dev/lockfile.js';
 import { resolveRoot } from '../../core/config/config.js';
 
+const require = createRequire(import.meta.url);
+
 export interface BackgroundResult {
 	pid: number;
 	url: string;
@@ -120,7 +123,11 @@ export async function background({
 	// On Windows, .bin shims are .cmd batch files that cannot be spawned without
 	// a shell, so we avoid the shim entirely for cross-platform compatibility.
 	const rootPath = fileURLToPath(root);
-	const astroBin = resolve(rootPath, 'node_modules', 'astro', 'bin', 'astro.mjs');
+	// Resolve astro's entry from its own package location rather than the project
+	// root: in a hoisted monorepo (e.g. bun workspaces) `astro` is deduped to the
+	// workspace-root node_modules, so a project-relative path does not exist.
+	// `astro/bin/astro.mjs` is not exported, so resolve via the package manifest.
+	const astroBin = resolve(dirname(require.resolve('astro/package.json')), 'bin', 'astro.mjs');
 
 	// Spawn the dev server as a detached child process
 	const child = spawn(process.execPath, [astroBin, ...args], {

From 72e29bd7f9d6c9f86febf5c9b97417bc90de5bb1 Mon Sep 17 00:00:00 2001
From: Martin Trapp <94928215+martrapp@users.noreply.github.com>
Date: Tue, 30 Jun 2026 20:00:05 +0200
Subject: [PATCH 5/7] fix(client router): prevent head elements loss during
 page transitions with server:defer component (#17123)

* fix(transitions): prevent head elements loss during page transitions with server:defer component

* Potential fix for pull request finding

The test description mentions client:defer, but the fixture uses server:defer (server island). This makes the test intent misleading when debugging failures. (Copilot code review)

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* reformat

* introduce SERVER_ISLAND_START constant to improve maintainability

* fixed broken syntax

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 .changeset/every-breads-hope.md               |  5 +++++
 .../src/components/ServerIsland.astro         |  1 +
 .../view-transitions/src/pages/deferred.astro | 13 +++++++++++++
 packages/astro/e2e/view-transitions.test.ts   | 17 +++++++++++++++++
 .../server/render/server-islands-shared.ts    |  1 +
 .../runtime/server/render/server-islands.ts   |  5 +++--
 .../astro/src/transitions/swap-functions.ts   | 19 +++++++++++++++++--
 7 files changed, 57 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/every-breads-hope.md
 create mode 100644 packages/astro/e2e/fixtures/view-transitions/src/components/ServerIsland.astro
 create mode 100644 packages/astro/e2e/fixtures/view-transitions/src/pages/deferred.astro
 create mode 100644 packages/astro/src/runtime/server/render/server-islands-shared.ts

diff --git a/.changeset/every-breads-hope.md b/.changeset/every-breads-hope.md
new file mode 100644
index 000000000000..03b8e81ced48
--- /dev/null
+++ b/.changeset/every-breads-hope.md
@@ -0,0 +1,5 @@
+---
+'astro': patch
+---
+
+Fixes an issue where the ClientRouter wipes head elements after page transitions if the `<head>` contains a `server:defer` component.
diff --git a/packages/astro/e2e/fixtures/view-transitions/src/components/ServerIsland.astro b/packages/astro/e2e/fixtures/view-transitions/src/components/ServerIsland.astro
new file mode 100644
index 000000000000..1665e7712a3a
--- /dev/null
+++ b/packages/astro/e2e/fixtures/view-transitions/src/components/ServerIsland.astro
@@ -0,0 +1 @@
+<link rel="stylesheet" href="."/>
\ No newline at end of file
diff --git a/packages/astro/e2e/fixtures/view-transitions/src/pages/deferred.astro b/packages/astro/e2e/fixtures/view-transitions/src/pages/deferred.astro
new file mode 100644
index 000000000000..2427714ef1d6
--- /dev/null
+++ b/packages/astro/e2e/fixtures/view-transitions/src/pages/deferred.astro
@@ -0,0 +1,13 @@
+---
+import {ClientRouter} from 'astro:transitions';
+import ServerIsland from '../components/ServerIsland.astro';
+---
+<head>
+  <link rel="stylesheet" href="before"/>
+  <ClientRouter />
+  <ServerIsland server:defer />
+  <link rel="stylesheet" href="after"/>
+</head>
+<body>
+  <a id="deferred" href="/deferred">Click</a>
+</body>
\ No newline at end of file
diff --git a/packages/astro/e2e/view-transitions.test.ts b/packages/astro/e2e/view-transitions.test.ts
index 2df331d46eab..de048b3c733d 100644
--- a/packages/astro/e2e/view-transitions.test.ts
+++ b/packages/astro/e2e/view-transitions.test.ts
@@ -1868,4 +1868,21 @@ test.describe('View Transitions', () => {
 			page.locator('[data-vite-dev-id*="VueCounter.vue?vue&type=style"][data-marker="this"]'),
 		).toHaveCount(1);
 	});
+
+	test('no children get lost if there is a `server:defer` component in the head', async ({
+		page,
+		astro,
+	}) => {
+		await page.goto(astro.resolveUrl('/deferred'));
+		await expect(page.locator('head link[rel="stylesheet"][href="."]')).toHaveCount(1);
+		await expect(page.locator('head link[rel="stylesheet"][href="after"]')).toHaveCount(1);
+		await expect(page.locator('head link[rel="stylesheet"][href="before"]')).toHaveCount(1);
+
+		await page.click('#deferred');
+		await page.waitForLoadState('networkidle');
+
+		await expect(page.locator('head link[rel="stylesheet"][href="."]')).toHaveCount(1);
+		await expect(page.locator('head link[rel="stylesheet"][href="after"]')).toHaveCount(1);
+		await expect(page.locator('head link[rel="stylesheet"][href="before"]')).toHaveCount(1);
+	});
 });
diff --git a/packages/astro/src/runtime/server/render/server-islands-shared.ts b/packages/astro/src/runtime/server/render/server-islands-shared.ts
new file mode 100644
index 000000000000..3e9b46edb0d1
--- /dev/null
+++ b/packages/astro/src/runtime/server/render/server-islands-shared.ts
@@ -0,0 +1 @@
+export const SERVER_ISLAND_START = '[if astro]>server-island-start<![endif]';
\ No newline at end of file
diff --git a/packages/astro/src/runtime/server/render/server-islands.ts b/packages/astro/src/runtime/server/render/server-islands.ts
index 62b211866272..9fdc98d4e66e 100644
--- a/packages/astro/src/runtime/server/render/server-islands.ts
+++ b/packages/astro/src/runtime/server/render/server-islands.ts
@@ -5,6 +5,7 @@ import { renderChild } from './any.js';
 import { createThinHead, type ThinHead } from './astro/head-and-content.js';
 import type { RenderDestination } from './common.js';
 import { createRenderInstruction } from './instruction.js';
+import { SERVER_ISLAND_START } from './server-islands-shared.js';
 import { type ComponentSlots, type SlotString, renderSlotToString } from './slot.js';
 
 const internalProps = new Set([
@@ -76,7 +77,7 @@ export class ServerIslandComponent {
 		const hostId = await this.getHostId();
 		const islandContent = await this.getIslandContent();
 		destination.write(createRenderInstruction({ type: 'server-island-runtime' }));
-		destination.write('<!--[if astro]>server-island-start<![endif]-->');
+		destination.write(`<!--${SERVER_ISLAND_START}-->`);
 		// Render the slots
 		for (const name in this.slots) {
 			if (name === 'fallback') {
@@ -240,7 +241,7 @@ const SERVER_ISLAND_REPLACER = markHTMLString(
 	// Load the HTML before modifying the DOM in case of errors
 	let html = await r.text();
 	// Remove any placeholder content before the island script
-	while (s.previousSibling && s.previousSibling.nodeType !== 8 && s.previousSibling.data !== '[if astro]>server-island-start<![endif]')
+	while (s.previousSibling && s.previousSibling.nodeType !== 8 && s.previousSibling.data !== '${SERVER_ISLAND_START}')
 		s.previousSibling.remove();
 	s.previousSibling?.remove();
 	// Insert the new HTML
diff --git a/packages/astro/src/transitions/swap-functions.ts b/packages/astro/src/transitions/swap-functions.ts
index 4956ee574ad2..83c4368166a1 100644
--- a/packages/astro/src/transitions/swap-functions.ts
+++ b/packages/astro/src/transitions/swap-functions.ts
@@ -1,3 +1,5 @@
+import { SERVER_ISLAND_START } from "../runtime/server/render/server-islands-shared.js";
+
 export type SavedFocus = {
 	activeElement: HTMLElement | null;
 	start?: number | null;
@@ -56,6 +58,15 @@ export function swapRootAttributes(newDoc: Document) {
  * make the old head look like the new one
  */
 export function swapHeadElements(doc: Document) {
+	// Elements and special server island comments
+	const relevantNodes = (parent: Node, what: 'commentsOnly' | 'both' = 'both') => [
+		...[...parent.childNodes].filter(
+			(child) =>
+				(child.nodeType === 8 && child.textContent === SERVER_ISLAND_START) ||
+				(what === 'both' && child.nodeType === 1),
+		),
+	];
+
 	for (const el of Array.from(document.head.children)) {
 		const newEl = persistedHeadElement(el as HTMLElement, doc);
 		// If the element exists in the document already, remove it
@@ -73,14 +84,18 @@ export function swapHeadElements(doc: Document) {
 		}
 	}
 
+	// Remove stale server island markers
+	// that may have been left behind from a previous navigation.
+	relevantNodes(document.head, 'commentsOnly').forEach((node) => node.remove());
+
 	// Everything left in the new head is new, append it all.
 	if (import.meta.env.DEV) {
 		// In DEV mode, replace known Vue scoped styles with the versions we remembered
-		[...doc.head.children].forEach((child) => {
+		relevantNodes(doc.head).forEach((child) => {
 			document.head.append(knownVueScopedStyles.get((child as any).dataset?.viteDevId) || child);
 		});
 	} else {
-		document.head.append(...doc.head.children);
+		document.head.append(...relevantNodes(doc.head));
 	}
 }
 

From 807c8fdc53846d5b9988468ae478625d697b4cca Mon Sep 17 00:00:00 2001
From: Martin Trapp <martrapp@users.noreply.github.com>
Date: Tue, 30 Jun 2026 18:01:43 +0000
Subject: [PATCH 6/7] [ci] format

---
 .../astro/src/runtime/server/render/server-islands-shared.ts    | 2 +-
 packages/astro/src/transitions/swap-functions.ts                | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/astro/src/runtime/server/render/server-islands-shared.ts b/packages/astro/src/runtime/server/render/server-islands-shared.ts
index 3e9b46edb0d1..832532720cb5 100644
--- a/packages/astro/src/runtime/server/render/server-islands-shared.ts
+++ b/packages/astro/src/runtime/server/render/server-islands-shared.ts
@@ -1 +1 @@
-export const SERVER_ISLAND_START = '[if astro]>server-island-start<![endif]';
\ No newline at end of file
+export const SERVER_ISLAND_START = '[if astro]>server-island-start<![endif]';
diff --git a/packages/astro/src/transitions/swap-functions.ts b/packages/astro/src/transitions/swap-functions.ts
index 83c4368166a1..abf449356dc5 100644
--- a/packages/astro/src/transitions/swap-functions.ts
+++ b/packages/astro/src/transitions/swap-functions.ts
@@ -1,4 +1,4 @@
-import { SERVER_ISLAND_START } from "../runtime/server/render/server-islands-shared.js";
+import { SERVER_ISLAND_START } from '../runtime/server/render/server-islands-shared.js';
 
 export type SavedFocus = {
 	activeElement: HTMLElement | null;

From d6ce7cd5d876c4fea3b27268e984259f57ed82c9 Mon Sep 17 00:00:00 2001
From: "Houston (Bot)" <108291165+astrobot-houston@users.noreply.github.com>
Date: Tue, 30 Jun 2026 11:54:39 -0700
Subject: [PATCH 7/7] Fix inline `<style>` blocks ignoring `vite.build.target`
 when `cssMinify` is false (#17226)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(build): apply CSS target lowering when cssMinify is disabled (#17225)

When `vite.build.minify: false` is set, Astro couples `cssMinify` to
`minify`, forcing `cssMinify: false`. Vite's CSS target lowering only
runs inside `finalizeCss` → `minifyCSS`, which is gated on `cssMinify`
being truthy. This means no CSS gets target-lowered — neither imported
stylesheets nor inline `.astro` `<style>` blocks.

Add a new Vite plugin (`astro:css-target-lowering`) that applies
lightningcss target lowering with `minify: false` to all CSS assets in
`generateBundle` when `cssMinify` is falsy and a CSS target is
configured. This decouples target lowering from minification, ensuring
CSS respects the configured `build.target`/`cssTarget` regardless of
minification settings.

The plugin:
- Converts esbuild/Vite target strings to lightningcss format
- Resolves lightningcss from Vite's dependencies (not a direct dep)
- Runs in generateBundle before inline-stylesheets processing
- Only activates when cssMinify is disabled and cssTarget is set

* fix(ci): update pnpm-lock.yaml for new test fixture

---------

Co-authored-by: Matthew Phillips <matthew@matthewphillips.info>
---
 .../astro/src/core/build/plugins/index.ts     |   2 +
 .../plugins/plugin-css-target-lowering.ts     | 124 ++++++++++++++++++
 .../config-vite-css-target-no-minify.test.ts  |  76 +++++++++++
 .../astro.config.mjs                          |  13 ++
 .../package.json                              |   8 ++
 .../src/pages/index.astro                     |  28 ++++
 .../src/styles/global.css                     |  44 +++++++
 pnpm-lock.yaml                                |   6 +
 8 files changed, 301 insertions(+)
 create mode 100644 packages/astro/src/core/build/plugins/plugin-css-target-lowering.ts
 create mode 100644 packages/astro/test/config-vite-css-target-no-minify.test.ts
 create mode 100644 packages/astro/test/fixtures/config-vite-css-target-no-minify/astro.config.mjs
 create mode 100644 packages/astro/test/fixtures/config-vite-css-target-no-minify/package.json
 create mode 100644 packages/astro/test/fixtures/config-vite-css-target-no-minify/src/pages/index.astro
 create mode 100644 packages/astro/test/fixtures/config-vite-css-target-no-minify/src/styles/global.css

diff --git a/packages/astro/src/core/build/plugins/index.ts b/packages/astro/src/core/build/plugins/index.ts
index e48f93106596..4dd43e59ca05 100644
--- a/packages/astro/src/core/build/plugins/index.ts
+++ b/packages/astro/src/core/build/plugins/index.ts
@@ -6,6 +6,7 @@ import type { StaticBuildOptions } from '../types.js';
 import { pluginAnalyzer } from './plugin-analyzer.js';
 import { pluginComponentEntry } from './plugin-component-entry.js';
 import { pluginCSS } from './plugin-css.js';
+import { pluginCssTargetLowering } from './plugin-css-target-lowering.js';
 import { pluginInternals } from './plugin-internals.js';
 import { pluginMiddleware } from './plugin-middleware.js';
 import { pluginPrerender } from './plugin-prerender.js';
@@ -25,6 +26,7 @@ export function getAllBuildPlugins(
 		pluginInternals(options, internals),
 		pluginMiddleware(options, internals),
 		vitePluginActionsBuild(options, internals),
+		pluginCssTargetLowering(),
 		...pluginCSS(options, internals),
 		astroHeadBuildPlugin(internals),
 		pluginPrerender(options, internals),
diff --git a/packages/astro/src/core/build/plugins/plugin-css-target-lowering.ts b/packages/astro/src/core/build/plugins/plugin-css-target-lowering.ts
new file mode 100644
index 000000000000..61e2da8f7ca5
--- /dev/null
+++ b/packages/astro/src/core/build/plugins/plugin-css-target-lowering.ts
@@ -0,0 +1,124 @@
+import { createRequire } from 'node:module';
+import type { Plugin as VitePlugin, ResolvedConfig } from 'vite';
+
+/**
+ * Browser name mapping from esbuild/Vite target format to lightningcss target format.
+ * Matches Vite's internal `map` object in `convertTargets`.
+ */
+const BROWSER_MAP: Record<string, string | false> = {
+	chrome: 'chrome',
+	edge: 'edge',
+	firefox: 'firefox',
+	hermes: false,
+	ie: 'ie',
+	ios: 'ios_saf',
+	node: false,
+	opera: 'opera',
+	rhino: false,
+	safari: 'safari',
+};
+
+const VERSION_RE = /\d/;
+
+/**
+ * Converts esbuild/Vite target strings (e.g. `["safari15", "chrome100"]`) to
+ * lightningcss target format (e.g. `{ safari: 983040, chrome: 6553600 }`).
+ *
+ * This replicates Vite's internal `convertTargets` function, which is not exported.
+ */
+function convertTargets(esbuildTarget: string | string[] | undefined): Record<string, number> {
+	if (!esbuildTarget) return {};
+	const targets: Record<string, number> = {};
+	const entries = Array.isArray(esbuildTarget) ? esbuildTarget : [esbuildTarget];
+	for (const entry of entries) {
+		if (entry === 'esnext') continue;
+		const index = entry.search(VERSION_RE);
+		if (index >= 0) {
+			const browserName = entry.slice(0, index);
+			const browser = BROWSER_MAP[browserName];
+			if (browser === false) continue;
+			if (browser) {
+				const [major, minor = 0] = entry
+					.slice(index)
+					.split('.')
+					.map((v) => Number.parseInt(v, 10));
+				if (!isNaN(major) && !isNaN(minor)) {
+					const version = (major << 16) | (minor << 8);
+					if (!targets[browser] || version < targets[browser]) {
+						targets[browser] = version;
+					}
+				}
+			}
+		}
+	}
+	return targets;
+}
+
+/**
+ * Vite plugin that applies CSS target lowering without minification.
+ *
+ * Vite's `finalizeCss` only applies CSS target lowering (via lightningcss) when
+ * `config.build.cssMinify` is truthy, because target lowering and minification
+ * are coupled in `minifyCSS`. When users set `minify: false`, Astro forces
+ * `cssMinify: false`, which disables target lowering for all CSS.
+ *
+ * This plugin fills that gap: when `cssMinify` is falsy and a CSS target is
+ * configured, it runs lightningcss with `minify: false` on all CSS assets in
+ * `generateBundle`, applying target lowering without minification.
+ */
+export function pluginCssTargetLowering(): VitePlugin {
+	let resolvedConfig: ResolvedConfig;
+
+	return {
+		name: 'astro:css-target-lowering',
+		enforce: 'post',
+
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+
+		async generateBundle(_outputOptions, bundle) {
+			// Only apply when cssMinify is disabled and a CSS target is configured
+			if (resolvedConfig.build.cssMinify) return;
+			const cssTarget = resolvedConfig.build.cssTarget;
+			if (!cssTarget) return;
+
+			const targets = convertTargets(cssTarget);
+			if (Object.keys(targets).length === 0) return;
+
+			// Resolve lightningcss from Vite's dependencies (it's not a direct Astro dep)
+			let lcssTransform: (opts: Record<string, unknown>) => {
+				code: Uint8Array;
+				warnings: unknown[];
+			};
+			try {
+				const requireFromVite = createRequire(import.meta.resolve('vite'));
+				lcssTransform = (requireFromVite('lightningcss') as { transform: typeof lcssTransform })
+					.transform;
+			} catch {
+				// If lightningcss is not available, skip silently
+				return;
+			}
+
+			for (const [, asset] of Object.entries(bundle)) {
+				if (asset.type !== 'asset') continue;
+				if (!asset.fileName.endsWith('.css')) continue;
+				if (typeof asset.source !== 'string') continue;
+
+				try {
+					const result = lcssTransform({
+						...resolvedConfig.css?.lightningcss,
+						targets,
+						cssModules: undefined,
+						filename: asset.fileName,
+						code: Buffer.from(asset.source),
+						minify: false,
+					});
+					asset.source = new TextDecoder().decode(result.code);
+				} catch {
+					// If transformation fails, leave the CSS unchanged
+				}
+			}
+		},
+	};
+}
diff --git a/packages/astro/test/config-vite-css-target-no-minify.test.ts b/packages/astro/test/config-vite-css-target-no-minify.test.ts
new file mode 100644
index 000000000000..71a66455ae1d
--- /dev/null
+++ b/packages/astro/test/config-vite-css-target-no-minify.test.ts
@@ -0,0 +1,76 @@
+/**
+ * Tests that CSS target lowering works when `vite.build.minify` is `false`.
+ *
+ * Regression test for https://github.com/withastro/astro/issues/17225
+ */
+
+import assert from 'node:assert/strict';
+import { before, describe, it } from 'node:test';
+import * as cheerio from 'cheerio';
+import { loadFixture, type Fixture } from './test-utils.ts';
+
+let fixture: Fixture;
+
+describe('CSS target lowering with minify: false', function () {
+	before(async () => {
+		fixture = await loadFixture({
+			root: './fixtures/config-vite-css-target-no-minify/',
+			outDir: './dist/config-vite-css-target-no-minify/',
+		});
+	});
+
+	describe('build', () => {
+		let html: string;
+		let $: cheerio.CheerioAPI;
+		let bundledCSS: string;
+
+		before(async () => {
+			await fixture.build();
+			html = await fixture.readFile('/index.html');
+			$ = cheerio.load(html);
+			const bundledCSSHREF = $('link[rel=stylesheet][href^=/_astro/]').attr('href')!;
+			bundledCSS = await fixture.readFile(bundledCSSHREF.replace(/^\/?/, '/'));
+		});
+
+		it('CSS is not minified (multi-line)', () => {
+			// Unminified CSS has newlines
+			assert.ok(bundledCSS.includes('\n'), 'CSS should contain newlines (not minified)');
+		});
+
+		it('imported CSS with width >= syntax is lowered to min-width for safari15', () => {
+			// global.css contains `@media screen and (width >= 1000px)` which should be
+			// lowered to `min-width: 1000px` for safari15 target
+			assert.ok(
+				!bundledCSS.includes('width >= 1000px'),
+				'CSS should not contain "width >= 1000px" (should be lowered to min-width)',
+			);
+			assert.ok(
+				bundledCSS.includes('min-width: 1000px'),
+				'CSS should contain "min-width: 1000px" (lowered from width >= for safari15)',
+			);
+		});
+
+		it('inline .astro styles are target-lowered', () => {
+			// The inline style has `@media screen and (width >= 1111px)` which should
+			// be lowered to `min-width: 1111px` for safari15
+			assert.ok(
+				!bundledCSS.includes('width >= 1111px'),
+				'CSS should not contain "width >= 1111px" (should be lowered)',
+			);
+			assert.ok(
+				bundledCSS.includes('min-width: 1111px'),
+				'CSS should contain "min-width: 1111px" (lowered from width >= for safari15)',
+			);
+		});
+
+		it('inline .astro styles with min-width are preserved', () => {
+			// The inline style has `@media screen and (min-width: 555px)` which should
+			// stay as-is (already compatible with safari15). The compiler may modernize
+			// it to `width >= 555px`, but target lowering should reverse that.
+			assert.ok(
+				bundledCSS.includes('min-width: 555px'),
+				'CSS should contain "min-width: 555px" (preserved or lowered back)',
+			);
+		});
+	});
+});
diff --git a/packages/astro/test/fixtures/config-vite-css-target-no-minify/astro.config.mjs b/packages/astro/test/fixtures/config-vite-css-target-no-minify/astro.config.mjs
new file mode 100644
index 000000000000..46deb0f33bdd
--- /dev/null
+++ b/packages/astro/test/fixtures/config-vite-css-target-no-minify/astro.config.mjs
@@ -0,0 +1,13 @@
+import { defineConfig } from 'astro/config';
+
+export default defineConfig({
+  build: {
+    inlineStylesheets: 'never',
+  },
+  vite: {
+    build: {
+      target: ["safari15"],
+      minify: false,
+    },
+  },
+});
diff --git a/packages/astro/test/fixtures/config-vite-css-target-no-minify/package.json b/packages/astro/test/fixtures/config-vite-css-target-no-minify/package.json
new file mode 100644
index 000000000000..ffa48f48d77f
--- /dev/null
+++ b/packages/astro/test/fixtures/config-vite-css-target-no-minify/package.json
@@ -0,0 +1,8 @@
+{
+  "name": "@test/config-vite-css-target-no-minify",
+  "version": "0.0.0",
+  "private": true,
+  "dependencies": {
+    "astro": "workspace:*"
+  }
+}
diff --git a/packages/astro/test/fixtures/config-vite-css-target-no-minify/src/pages/index.astro b/packages/astro/test/fixtures/config-vite-css-target-no-minify/src/pages/index.astro
new file mode 100644
index 000000000000..be7a50895c3b
--- /dev/null
+++ b/packages/astro/test/fixtures/config-vite-css-target-no-minify/src/pages/index.astro
@@ -0,0 +1,28 @@
+---
+import "../styles/global.css";
+---
+
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+    <title>CSS Target No Minify</title>
+  </head>
+  <body>
+    <h1>CSS Target No Minify Test</h1>
+  </body>
+</html>
+
+<style>
+  @media screen and (min-width: 555px) {
+    body {
+      background: yellow;
+    }
+  }
+
+  @media screen and (width >= 1111px) {
+    body {
+      background: red;
+    }
+  }
+</style>
diff --git a/packages/astro/test/fixtures/config-vite-css-target-no-minify/src/styles/global.css b/packages/astro/test/fixtures/config-vite-css-target-no-minify/src/styles/global.css
new file mode 100644
index 000000000000..00ce50186417
--- /dev/null
+++ b/packages/astro/test/fixtures/config-vite-css-target-no-minify/src/styles/global.css
@@ -0,0 +1,44 @@
+/* Global CSS - tests that imported CSS also respects target */
+@media screen and (min-width: 500px) {
+  body {
+    background: skyblue;
+  }
+}
+
+@media screen and (width >= 1000px) {
+  body {
+    background: plum;
+  }
+}
+
+/* Padding to ensure this doesn't get inlined */
+.pad1 { color: red; }
+.pad2 { color: blue; }
+.pad3 { color: green; }
+.pad4 { color: yellow; }
+.pad5 { color: orange; }
+.pad6 { color: purple; }
+.pad7 { color: pink; }
+.pad8 { color: brown; }
+.pad9 { color: black; }
+.pad10 { color: white; }
+.pad11 { color: gray; }
+.pad12 { color: cyan; }
+.pad13 { color: magenta; }
+.pad14 { color: lime; }
+.pad15 { color: olive; }
+.pad16 { color: navy; }
+.pad17 { color: teal; }
+.pad18 { color: maroon; }
+.pad19 { color: aqua; }
+.pad20 { color: fuchsia; }
+.pad21 { color: silver; }
+.pad22 { color: coral; }
+.pad23 { color: salmon; }
+.pad24 { color: tomato; }
+.pad25 { color: crimson; }
+.pad26 { color: orchid; }
+.pad27 { color: violet; }
+.pad28 { color: indigo; }
+.pad29 { color: khaki; }
+.pad30 { color: linen; }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 012ff010abe1..b7c70c6fd29d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2564,6 +2564,12 @@ importers:
         specifier: workspace:*
         version: link:../../..
 
+  packages/astro/test/fixtures/config-vite-css-target-no-minify:
+    dependencies:
+      astro:
+        specifier: workspace:*
+        version: link:../../..
+
   packages/astro/test/fixtures/container-custom-renderers:
     dependencies:
       '@astrojs/react':