diff --git a/.changeset/rust-compiler-experimental.md b/.changeset/rust-compiler-experimental.md
new file mode 100644
index 000000000000..8d343f84b4b6
--- /dev/null
+++ b/.changeset/rust-compiler-experimental.md
@@ -0,0 +1,23 @@
+---
+'astro': minor
+---
+
+Adds a new `experimental.rustCompiler` flag to opt into the experimental Rust-based Astro compiler
+
+This experimental compiler is faster, provides better error messages, and generally has better support for modern JavaScript, TypeScript, and CSS features.
+
+After enabling in your Astro config, the `@astrojs/compiler-rs` package must also be installed into your project separately:
+
+```js
+import { defineConfig } from "astro/config";
+
+export default defineConfig({
+  experimental: {
+    rustCompiler: true
+  }
+});
+```
+
+This new compiler is still in early development and may exhibit some differences compared to the existing Go-based compiler. Notably, this compiler is generally more strict in regard to invalid  HTML syntax and may throw errors in cases where the Go-based compiler would have been more lenient. For example, unclosed tags (e.g. `<p>My paragraph`) will now result in errors.
+
+For more information about using this experimental feature in your project, especially regarding expected differences and limitations, please see the [experimental Rust compiler reference docs](https://v6.docs.astro.build/en/reference/experimental-flags/rust-compiler/). To give feedback on the compiler, or to keep up with its development, see the [RFC for a new compiler for Astro](https://github.com/withastro/roadmap/discussions/1306) for more information and discussion.
diff --git a/.github/workflows/continuous_benchmark.yml b/.github/workflows/continuous_benchmark.yml
index a25d7902be6a..d761fbee6817 100644
--- a/.github/workflows/continuous_benchmark.yml
+++ b/.github/workflows/continuous_benchmark.yml
@@ -23,6 +23,7 @@ env:
 
 jobs:
   codspeed:
+    if: ${{ github.repository_owner == 'withastro' }}
     runs-on: ubuntu-latest
     strategy:
       matrix:
diff --git a/.github/workflows/examples-deploy.yml b/.github/workflows/examples-deploy.yml
index ae56c4b3255c..95f7ba92237f 100644
--- a/.github/workflows/examples-deploy.yml
+++ b/.github/workflows/examples-deploy.yml
@@ -13,7 +13,10 @@ on:
 
 jobs:
   deploy:
+    if: ${{ github.repository_owner == 'withastro' }}
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Send a POST request to Netlify to rebuild preview.astro.new
diff --git a/.github/workflows/issue-triage.yml b/.github/workflows/issue-triage.yml
index 40151d5c9968..9cc283c5686d 100644
--- a/.github/workflows/issue-triage.yml
+++ b/.github/workflows/issue-triage.yml
@@ -84,10 +84,15 @@ jobs:
       - name: Build
         run: pnpm build
 
+      - name: Log in to GHCR
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Pull sandbox image
-        run: |
-          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
-          docker pull $IMAGE:latest
+        run: docker pull $IMAGE:latest
 
       - name: Verify sandbox image
         run: |
diff --git a/packages/astro/package.json b/packages/astro/package.json
index 53b7ca469dc9..3d8945f7d2cc 100644
--- a/packages/astro/package.json
+++ b/packages/astro/package.json
@@ -178,6 +178,7 @@
   },
   "devDependencies": {
     "@astrojs/check": "workspace:*",
+    "@astrojs/compiler-rs": "^0.1.1",
     "@playwright/test": "1.58.2",
     "@types/aria-query": "^5.0.4",
     "@types/cssesc": "^3.0.2",
diff --git a/packages/astro/src/core/compile/compile-rs.ts b/packages/astro/src/core/compile/compile-rs.ts
new file mode 100644
index 000000000000..c3a296de358d
--- /dev/null
+++ b/packages/astro/src/core/compile/compile-rs.ts
@@ -0,0 +1,155 @@
+import { fileURLToPath } from 'node:url';
+import type { ResolvedConfig } from 'vite';
+import type { AstroConfig } from '../../types/public/config.js';
+import type { AstroError } from '../errors/errors.js';
+import { AggregateError, CompilerError } from '../errors/errors.js';
+import { AstroErrorData } from '../errors/index.js';
+import { normalizePath, resolvePath } from '../viteUtils.js';
+import { createStylePreprocessor, type PartialCompileCssResult } from './style.js';
+import type { CompileCssResult } from './types.js';
+
+export interface CompileProps {
+	astroConfig: AstroConfig;
+	viteConfig: ResolvedConfig;
+	toolbarEnabled: boolean;
+	filename: string;
+	source: string;
+}
+
+export interface CompileResult {
+	code: string;
+	map: string;
+	scope: string;
+	css: CompileCssResult[];
+	scripts: any[];
+	hydratedComponents: any[];
+	clientOnlyComponents: any[];
+	serverComponents: any[];
+	containsHead: boolean;
+	propagation: boolean;
+	styleError: string[];
+	diagnostics: any[];
+}
+
+export async function compile({
+	astroConfig,
+	viteConfig,
+	toolbarEnabled,
+	filename,
+	source,
+}: CompileProps): Promise<CompileResult> {
+	let preprocessStyles;
+	let transform;
+	try {
+		({ preprocessStyles, transform } = await import('@astrojs/compiler-rs'));
+	} catch (err: unknown) {
+		throw new Error(
+			`Failed to load @astrojs/compiler-rs. Make sure it is installed and up to date. Original error: ${err}`,
+		);
+	}
+
+	const cssPartialCompileResults: PartialCompileCssResult[] = [];
+	const cssTransformErrors: AstroError[] = [];
+	let transformResult: any;
+
+	try {
+		const preprocessedStyles = await preprocessStyles(
+			source,
+			createStylePreprocessor({
+				filename,
+				viteConfig,
+				astroConfig,
+				cssPartialCompileResults,
+				cssTransformErrors,
+			}),
+		);
+
+		transformResult = transform(source, {
+			compact: astroConfig.compressHTML,
+			filename,
+			normalizedFilename: normalizeFilename(filename, astroConfig.root),
+			sourcemap: 'both',
+			internalURL: 'astro/compiler-runtime',
+			// TODO: remove in Astro v7
+			astroGlobalArgs: JSON.stringify(astroConfig.site),
+			scopedStyleStrategy: astroConfig.scopedStyleStrategy,
+			resultScopedSlot: true,
+			transitionsAnimationURL: 'astro/components/viewtransitions.css',
+			annotateSourceFile:
+				viteConfig.command === 'serve' &&
+				astroConfig.devToolbar &&
+				astroConfig.devToolbar.enabled &&
+				toolbarEnabled,
+			preprocessedStyles,
+			resolvePath(specifier) {
+				return resolvePath(specifier, filename);
+			},
+		});
+	} catch (err: any) {
+		// The compiler should be able to handle errors by itself, however
+		// for the rare cases where it can't let's directly throw here with as much info as possible
+		throw new CompilerError({
+			...AstroErrorData.UnknownCompilerError,
+			message: err.message ?? 'Unknown compiler error',
+			stack: err.stack,
+			location: {
+				file: filename,
+			},
+		});
+	}
+
+	handleCompileResultErrors(filename, transformResult, cssTransformErrors);
+
+	return {
+		...transformResult,
+		css: transformResult.css.map((code: string, i: number) => ({
+			...cssPartialCompileResults[i],
+			code,
+		})),
+	};
+}
+
+function handleCompileResultErrors(
+	filename: string,
+	result: any,
+	cssTransformErrors: AstroError[],
+) {
+	const compilerError = result.diagnostics.find((diag: any) => diag.severity === 'error');
+
+	if (compilerError) {
+		throw new CompilerError({
+			name: 'CompilerError',
+			message: compilerError.text,
+			location: {
+				line: compilerError.labels[0].line,
+				column: compilerError.labels[0].column,
+				file: filename,
+			},
+			hint: compilerError.hint,
+		});
+	}
+
+	switch (cssTransformErrors.length) {
+		case 0:
+			break;
+		case 1: {
+			throw cssTransformErrors[0];
+		}
+		default: {
+			throw new AggregateError({
+				...cssTransformErrors[0],
+				errors: cssTransformErrors,
+			});
+		}
+	}
+}
+
+function normalizeFilename(filename: string, root: URL) {
+	const normalizedFilename = normalizePath(filename);
+	const normalizedRoot = normalizePath(fileURLToPath(root));
+	if (normalizedFilename.startsWith(normalizedRoot)) {
+		return normalizedFilename.slice(normalizedRoot.length - 1);
+	} else {
+		return normalizedFilename;
+	}
+}
diff --git a/packages/astro/src/core/compile/style.ts b/packages/astro/src/core/compile/style.ts
index d6e4dec983f6..91754c763034 100644
--- a/packages/astro/src/core/compile/style.ts
+++ b/packages/astro/src/core/compile/style.ts
@@ -1,5 +1,4 @@
 import fs from 'node:fs';
-import type { TransformOptions } from '@astrojs/compiler';
 import { preprocessCSS, type ResolvedConfig } from 'vite';
 import type { AstroConfig } from '../../types/public/config.js';
 import { AstroErrorData, CSSError, positionAt } from '../errors/index.js';
@@ -8,6 +7,20 @@ import type { CompileCssResult } from './types.js';
 
 export type PartialCompileCssResult = Pick<CompileCssResult, 'isGlobal' | 'dependencies'>;
 
+interface PreprocessorResult {
+	code: string;
+	map?: string;
+}
+
+interface PreprocessorError {
+	error: string;
+}
+
+export type PreprocessStyleFn = (
+	content: string,
+	attrs: Record<string, string>,
+) => Promise<PreprocessorResult | PreprocessorError>;
+
 /**
  * Rewrites absolute URLs in CSS to include the base path.
  *
@@ -90,7 +103,7 @@ export function createStylePreprocessor({
 	astroConfig: AstroConfig;
 	cssPartialCompileResults: Partial<CompileCssResult>[];
 	cssTransformErrors: Error[];
-}): TransformOptions['preprocessStyle'] {
+}): PreprocessStyleFn {
 	let processedStylesCount = 0;
 
 	return async (content, attrs) => {
@@ -105,7 +118,9 @@ export function createStylePreprocessor({
 			const rewrittenCode = rewriteCssUrls(result.code, astroConfig.base);
 
 			cssPartialCompileResults[index] = {
-				isGlobal: !!attrs['is:global'],
+				// Use `in` operator to handle both Go compiler (boolean `true`) and
+				// Rust compiler (empty string `""`) representations of boolean attributes.
+				isGlobal: 'is:global' in attrs,
 				dependencies: result.deps ? [...result.deps].map((dep) => normalizePath(dep)) : [],
 			};
 
diff --git a/packages/astro/src/core/config/schemas/base.ts b/packages/astro/src/core/config/schemas/base.ts
index 0b46bf1ab2c3..88b159485167 100644
--- a/packages/astro/src/core/config/schemas/base.ts
+++ b/packages/astro/src/core/config/schemas/base.ts
@@ -104,6 +104,7 @@ export const ASTRO_CONFIG_DEFAULTS = {
 		contentIntellisense: false,
 		chromeDevtoolsWorkspace: false,
 		svgo: false,
+		rustCompiler: false,
 	},
 } satisfies AstroUserConfig & { server: { open: boolean } };
 
@@ -493,6 +494,7 @@ export const AstroConfigSchema = z.object({
 				.union([z.boolean(), z.custom<SvgoConfig>((value) => value && typeof value === 'object')])
 				.optional()
 				.default(ASTRO_CONFIG_DEFAULTS.experimental.svgo),
+			rustCompiler: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.rustCompiler),
 		})
 		.prefault({}),
 	legacy: z
diff --git a/packages/astro/src/types/public/config.ts b/packages/astro/src/types/public/config.ts
index 47514027e4ed..05dccb0e1195 100644
--- a/packages/astro/src/types/public/config.ts
+++ b/packages/astro/src/types/public/config.ts
@@ -2763,6 +2763,30 @@ export interface AstroUserConfig<
 		 * See the [experimental SVGO optimization docs](https://docs.astro.build/en/reference/experimental-flags/svg-optimization/) for more information.
 		 */
 		svgo?: boolean | SvgoConfig;
+
+		/**
+		 * @name experimental.rustCompiler
+		 * @type {boolean}
+		 * @default `false`
+		 * @version 6.0.0
+		 * @description
+		 *
+		 * Enables the experimental Rust-based Astro compiler (`@astrojs/compiler-rs`) as a replacement to the current Go compiler.
+		 *
+		 * This option requires installing the `@astrojs/compiler-rs` package manually in your project. This compiler is a work in progress and may not yet support all features of the current Go compiler, but it should offer improved performance and better error messages. This compiler is more strict than the previous Go compiler regarding invalid syntax. For instance, unclosed HTML tags or missing closing brackets will throw an error instead of being ignored.
+		 *
+		 * ```js
+		 * // astro.config.mjs
+		 * import { defineConfig } from 'astro/config';
+		 *
+		 * export default defineConfig({
+		 *   experimental: {
+		 *     rustCompiler: true,
+		 *   },
+		 * });
+		 * ```
+		 */
+		rustCompiler?: boolean;
 	};
 }
 
diff --git a/packages/astro/src/vite-plugin-astro/compile-rs.ts b/packages/astro/src/vite-plugin-astro/compile-rs.ts
new file mode 100644
index 000000000000..9eff8a3916e5
--- /dev/null
+++ b/packages/astro/src/vite-plugin-astro/compile-rs.ts
@@ -0,0 +1,52 @@
+import type { SourceMapInput } from 'rollup';
+import { type CompileProps, type CompileResult, compile } from '../core/compile/compile-rs.js';
+import { getFileInfo } from '../vite-plugin-utils/index.js';
+import type { CompileMetadata } from './types.js';
+
+interface CompileAstroOption {
+	compileProps: CompileProps;
+	astroFileToCompileMetadata: Map<string, CompileMetadata>;
+}
+
+export interface CompileAstroResult extends Omit<CompileResult, 'map'> {
+	map: SourceMapInput;
+}
+
+export async function compileAstro({
+	compileProps,
+	astroFileToCompileMetadata,
+}: CompileAstroOption): Promise<CompileAstroResult> {
+	const transformResult = await compile(compileProps);
+
+	const { fileId: file, fileUrl: url } = getFileInfo(
+		compileProps.filename,
+		compileProps.astroConfig,
+	);
+
+	let SUFFIX = '';
+	SUFFIX += `\nconst $$file = ${JSON.stringify(file)};\nconst $$url = ${JSON.stringify(
+		url,
+	)};export { $$file as file, $$url as url };\n`;
+
+	// Add HMR handling in dev mode.
+	if (!compileProps.viteConfig.isProduction) {
+		let i = 0;
+		while (i < transformResult.scripts.length) {
+			SUFFIX += `import "${compileProps.filename}?astro&type=script&index=${i}&lang.ts";`;
+			i++;
+		}
+	}
+
+	// Attach compile metadata to map for use by virtual modules
+	astroFileToCompileMetadata.set(compileProps.filename, {
+		originalCode: compileProps.source,
+		css: transformResult.css,
+		scripts: transformResult.scripts,
+	});
+
+	return {
+		...transformResult,
+		code: transformResult.code + SUFFIX,
+		map: transformResult.map || null,
+	};
+}
diff --git a/packages/astro/src/vite-plugin-astro/compile.ts b/packages/astro/src/vite-plugin-astro/compile.ts
index 5000b42b70d7..0d8b000b29d6 100644
--- a/packages/astro/src/vite-plugin-astro/compile.ts
+++ b/packages/astro/src/vite-plugin-astro/compile.ts
@@ -5,6 +5,7 @@ import type { AstroConfig } from '../types/public/config.js';
 import { getFileInfo } from '../vite-plugin-utils/index.js';
 import type { CompileMetadata } from './types.js';
 import { frontmatterRE } from './utils.js';
+import type { SourceMapInput } from 'rollup';
 
 interface CompileAstroOption {
 	compileProps: CompileProps;
@@ -13,7 +14,7 @@ interface CompileAstroOption {
 }
 
 export interface CompileAstroResult extends Omit<CompileResult, 'map'> {
-	map: ESBuildTransformResult['map'];
+	map: SourceMapInput;
 }
 
 interface EnhanceCompilerErrorOptions {
diff --git a/packages/astro/src/vite-plugin-astro/index.ts b/packages/astro/src/vite-plugin-astro/index.ts
index 0e302c10fdd1..cf529e2e143b 100644
--- a/packages/astro/src/vite-plugin-astro/index.ts
+++ b/packages/astro/src/vite-plugin-astro/index.ts
@@ -9,6 +9,7 @@ import type { AstroSettings } from '../types/astro.js';
 import type { AstroConfig } from '../types/public/config.js';
 import { normalizeFilename, specialQueriesRE } from '../vite-plugin-utils/index.js';
 import { type CompileAstroResult, compileAstro } from './compile.js';
+import { compileAstro as compileAstroRs } from './compile-rs.js';
 import { handleHotUpdate } from './hmr.js';
 import { parseAstroRequest } from './query.js';
 import type { PluginMetadata as AstroPluginMetadata, CompileMetadata } from './types.js';
@@ -90,14 +91,21 @@ export default function astro({ settings, logger }: AstroPluginOptions): vite.Pl
 				const toolbarEnabled = await settings.preferences.get('devToolbar.enabled');
 				// Initialize `compile` function to simplify usage later
 				compile = (code, filename) => {
+					const compileProps = {
+						astroConfig: config,
+						viteConfig,
+						toolbarEnabled,
+						filename,
+						source: code,
+					};
+					if (config.experimental.rustCompiler) {
+						return compileAstroRs({
+							compileProps,
+							astroFileToCompileMetadata,
+						});
+					}
 					return compileAstro({
-						compileProps: {
-							astroConfig: config,
-							viteConfig,
-							toolbarEnabled,
-							filename,
-							source: code,
-						},
+						compileProps,
 						astroFileToCompileMetadata,
 						logger,
 					});
diff --git a/packages/astro/test/astro-partial-html.test.js b/packages/astro/test/astro-partial-html.test.js
index f6ea0de9525f..9d04ea0ba257 100644
--- a/packages/astro/test/astro-partial-html.test.js
+++ b/packages/astro/test/astro-partial-html.test.js
@@ -26,8 +26,8 @@ describe('Partial HTML', async () => {
 		assert.match(html, /^<!DOCTYPE html/);
 
 		// test 2: correct CSS present
-		const allInjectedStyles = $('style').text();
-		assert.match(allInjectedStyles, /\[data-astro-cid-[^{]+\{color:red\}/);
+		const allInjectedStyles = $('style').text().replace(/\s*/g, '');
+		assert.match(allInjectedStyles, /\[data-astro-cid-[^{]+\{color:red;?\}/);
 	});
 
 	it('injects framework styles', async () => {
diff --git a/packages/astro/test/content-collections-render.test.js b/packages/astro/test/content-collections-render.test.js
index 4e6b680b0446..77c7a6ab7c8b 100644
--- a/packages/astro/test/content-collections-render.test.js
+++ b/packages/astro/test/content-collections-render.test.js
@@ -215,7 +215,8 @@ describe('Content Collections - render()', () => {
 			let $ = cheerio.load(html);
 
 			// Includes the red button styles used in the MDX blog post
-			assert.ok($('head > style').text().includes('background-color:red;'));
+			// CSS may be minified (background-color:red) or pretty-printed (background-color: red)
+			assert.match($('head > style').text(), /background-color:\s*red/);
 
 			response = await fixture.fetch('/blog/about', { method: 'GET' });
 			assert.equal(response.status, 200);
@@ -224,7 +225,7 @@ describe('Content Collections - render()', () => {
 			$ = cheerio.load(html);
 
 			// Does not include the red button styles not used in this page
-			assert.equal($('head > style').text().includes('background-color:red;'), false);
+			assert.doesNotMatch($('head > style').text(), /background-color:\s*red/);
 		});
 	});
 });
diff --git a/packages/astro/test/css-order-import.test.js b/packages/astro/test/css-order-import.test.js
index f8a9cf5b2b02..6d94286f4568 100644
--- a/packages/astro/test/css-order-import.test.js
+++ b/packages/astro/test/css-order-import.test.js
@@ -74,8 +74,9 @@ describe('CSS ordering - import order', () => {
 			let [style1, style2, style3] = getStyles(html);
 
 			assert.ok(style1.includes('burlywood'));
-			assert.ok(style2.includes('aliceblue'));
-			assert.ok(style3.includes('whitesmoke'));
+			// CSS processors may resolve named colors to hex; match either form
+			assert.ok(style2.includes('aliceblue') || style2.includes('#f0f8ff'));
+			assert.ok(style3.includes('whitesmoke') || style3.includes('#f5f5f5'));
 		});
 	});
 
diff --git a/packages/astro/test/fixtures/astro-head/src/pages/head-own-component.astro b/packages/astro/test/fixtures/astro-head/src/pages/head-own-component.astro
index cbc99cb04169..ec951e3f5632 100644
--- a/packages/astro/test/fixtures/astro-head/src/pages/head-own-component.astro
+++ b/packages/astro/test/fixtures/astro-head/src/pages/head-own-component.astro
@@ -14,3 +14,4 @@ import Head from "../components/Head.astro";
 		}
 	</style>
 </body>
+</html>
diff --git a/packages/astro/test/fixtures/core-image-ssg/src/pages/special-chars.astro b/packages/astro/test/fixtures/core-image-ssg/src/pages/special-chars.astro
index c774e87f9028..fa127dc5deb5 100644
--- a/packages/astro/test/fixtures/core-image-ssg/src/pages/special-chars.astro
+++ b/packages/astro/test/fixtures/core-image-ssg/src/pages/special-chars.astro
@@ -8,4 +8,5 @@ import { Image } from 'astro:assets';
 </head>
 <body>
 	<Image src="https://kaleidoscopic-biscotti-6fe98c.netlify.app/c%2523.png" alt="C#" inferSize />
+</body>
 </html>
diff --git a/packages/astro/test/units/compile/rust-compiler.test.js b/packages/astro/test/units/compile/rust-compiler.test.js
new file mode 100644
index 000000000000..aaa5bbe6fe68
--- /dev/null
+++ b/packages/astro/test/units/compile/rust-compiler.test.js
@@ -0,0 +1,145 @@
+import * as assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { pathToFileURL } from 'node:url';
+import { resolveConfig } from 'vite';
+import { compile } from '../../../dist/core/compile/compile-rs.js';
+
+/**
+ * @param {string} source
+ * @param {object} [configOverrides]
+ */
+async function compileWithRust(source, configOverrides = {}) {
+	const viteConfig = await resolveConfig({ configFile: false }, 'serve');
+	return compile({
+		astroConfig: {
+			root: pathToFileURL('/'),
+			base: '/',
+			experimental: { rustCompiler: true },
+			compressHTML: false,
+			scopedStyleStrategy: 'attribute',
+			devToolbar: { enabled: false },
+			site: undefined,
+			...configOverrides,
+		},
+		viteConfig,
+		toolbarEnabled: false,
+		filename: '/src/components/index.astro',
+		source,
+	});
+}
+
+describe('experimental.rustCompiler - core compile', () => {
+	it('compiles a basic Astro component', async () => {
+		const result = await compileWithRust('<h1>Hello World</h1>');
+		assert.ok(result.code);
+	});
+
+	it('compiles a component with frontmatter', async () => {
+		const result = await compileWithRust(`\
+---
+const greeting = 'Hello';
+---
+<h1>{greeting}</h1>`);
+		assert.ok(result.code);
+	});
+
+	it('returns a source map', async () => {
+		const result = await compileWithRust('<h1>Hello</h1>');
+		assert.ok(result.map);
+	});
+
+	it('returns a scope string', async () => {
+		const result = await compileWithRust('<h1>Hello</h1>');
+		assert.equal(typeof result.scope, 'string');
+	});
+
+	it('returns populated css array for styled components', async () => {
+		const result = await compileWithRust(`\
+<style>h1 { color: red; }</style>
+<h1>Hello</h1>`);
+		assert.ok(Array.isArray(result.css));
+		assert.equal(result.css.length, 1);
+		assert.ok(result.css[0].code);
+	});
+
+	it('returns empty css array for unstyled components', async () => {
+		const result = await compileWithRust('<h1>Hello</h1>');
+		assert.ok(Array.isArray(result.css));
+		assert.equal(result.css.length, 0);
+	});
+
+	it('returns populated scripts array for components with scripts', async () => {
+		const result = await compileWithRust(`\
+<script>
+console.log('hello');
+</script>
+<h1>Hello</h1>`);
+		assert.ok(Array.isArray(result.scripts));
+		assert.equal(result.scripts.length, 1);
+	});
+
+	it('returns empty scripts array for components without scripts', async () => {
+		const result = await compileWithRust('<h1>Hello</h1>');
+		assert.ok(Array.isArray(result.scripts));
+		assert.equal(result.scripts.length, 0);
+	});
+
+	it('detects head content', async () => {
+		const result = await compileWithRust(`\
+<head>
+  <title>My Page</title>
+</head>
+<body><h1>Hello</h1></body>`);
+		assert.equal(result.containsHead, true);
+	});
+
+	it('reports containsHead as false when no head element present', async () => {
+		const result = await compileWithRust('<h1>Hello</h1>');
+		assert.equal(result.containsHead, false);
+	});
+
+	it('marks global styles with isGlobal', async () => {
+		const result = await compileWithRust(`\
+<style is:global>
+  h1 { color: blue; }
+</style>
+<h1>Global</h1>`);
+		assert.equal(result.css.length, 1);
+		assert.equal(result.css[0].isGlobal, true);
+	});
+
+	it('marks scoped styles with isGlobal false', async () => {
+		const result = await compileWithRust(`\
+<style>
+  h1 { color: blue; }
+</style>
+<h1>Scoped</h1>`);
+		assert.equal(result.css.length, 1);
+		assert.equal(result.css[0].isGlobal, false);
+	});
+
+	it('returns one css entry per style block', async () => {
+		const result = await compileWithRust(`\
+<style>h1 { color: red; }</style>
+<style>p { color: blue; }</style>
+<h1>Hello</h1>
+<p>World</p>`);
+		assert.equal(result.css.length, 2);
+	});
+
+	it('throws a CompilerError on unclosed tags', async () => {
+		await assert.rejects(
+			() => compileWithRust('<p>Unclosed tag'),
+			(err) => {
+				assert.ok(err.message || err.name);
+				assert.ok(err.message.includes('Unexpected token'));
+				return true;
+			},
+		);
+	});
+
+	it('handles empty component without throwing', async () => {
+		const result = await compileWithRust('');
+		assert.ok(result.code !== undefined);
+	});
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a886bf0e65a9..7564a7681c4a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -677,6 +677,9 @@ importers:
       '@astrojs/check':
         specifier: workspace:*
         version: link:../language-tools/astro-check
+      '@astrojs/compiler-rs':
+        specifier: ^0.1.1
+        version: 0.1.1
       '@playwright/test':
         specifier: 1.58.2
         version: 1.58.2
@@ -7117,6 +7120,70 @@ packages:
     resolution: {integrity: sha512-bVzyKzEpIwqjihBU/aUzt1LQckJuHK0agd3/ITdXhPUYculrc6K1/K7H+XG4rwjXtg+ikT3PM05V1MVYWiIvQw==}
     engines: {node: '>=18.14.1'}
 
+  '@astrojs/compiler-binding-darwin-arm64@0.1.1':
+    resolution: {integrity: sha512-W5jNq18skbt9a1eTou73O7c4GQwYiE41FGyvLeCYR44Btmd9SPLzPgwdsGIRyVEPuy9xXSMvFl4ncVEXn09CCQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@astrojs/compiler-binding-darwin-x64@0.1.1':
+    resolution: {integrity: sha512-U8NKnstwZWix4nPuLXcMU4Ni3r4Qe4CdwdBMVYXkFaaO4XJwOWDgEH7BXntrRAa3uleFKMIqpthoU9zZw4uwKg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@astrojs/compiler-binding-linux-arm64-gnu@0.1.1':
+    resolution: {integrity: sha512-UgEsnEd1yIwAYbeLRgavqAYKUNrMEtjwaNUcG0utEXPZpvvjexLS608q1UO0S96DVe4WBZkKrgcdmftbSJJdzA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@astrojs/compiler-binding-linux-arm64-musl@0.1.1':
+    resolution: {integrity: sha512-b9L5SSM9jzrz1GRTE22OioPKLAxgq91FxTVcq09of23AATXDWpxCaX2J1d+7jdSa1ANuImVsnni/za370/6r0g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@astrojs/compiler-binding-linux-x64-gnu@0.1.1':
+    resolution: {integrity: sha512-E6mGtZlsFsQ67qqGGaJMQFxCLbyCazwlwJZH3hsTcjwo1Z6c2FIb43sQ8O8txY7GOIYMrPUO5+LiGCY6E6GgDg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@astrojs/compiler-binding-linux-x64-musl@0.1.1':
+    resolution: {integrity: sha512-aNXZhmx7xSkOOdYNrvSl8jiVRostLymkt4oVp5I+N4YBXUAhkoDsbp1yLR/5i81tkkslvXmQX+RDHM1rdXTckQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@astrojs/compiler-binding-wasm32-wasi@0.1.1':
+    resolution: {integrity: sha512-Q3jcnpGVidSL8D5RAHFhwghc4/+95ZXJ2PQU4P0O3ATUY9ZUoROsWetLRtQ7/kdB6lUjJEKEQdTgn+OStxi+nw==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+
+  '@astrojs/compiler-binding-win32-arm64-msvc@0.1.1':
+    resolution: {integrity: sha512-QEo8oZXYA1U3/+gNyHCpOYaAzRVmJFxH/BCHJjvqlUn8wKuNXEfSu3E/5QWA8YaN5jcQAgGv8YZjOcU6XynSag==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@astrojs/compiler-binding-win32-x64-msvc@0.1.1':
+    resolution: {integrity: sha512-1+kuUy+zZE8/Cj7NffzaBAubbUx9WXxKrucVKTTyPJJlVk7N18G4/PtewiHuAg4my3wORkNns12WN1xYrZ7cuQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@astrojs/compiler-binding@0.1.1':
+    resolution: {integrity: sha512-V2kVIy1jPi97stjCjAMPbbdcRxSRwGptlYyspiEYCK1RztcXFcjaYeXfB084R2MhhTdZXSIeMfi3dWQ0rVKBjA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+
+  '@astrojs/compiler-rs@0.1.1':
+    resolution: {integrity: sha512-zzi4N9/FXLHs68cMF1NwxSWRRgtNhxaHOVGG4q9FPAIZlrvkU2kyhpoYYTkE9Ghp+oXOsF998AmdTP4uDqNxYw==}
+
   '@astrojs/compiler@2.13.1':
     resolution: {integrity: sha512-f3FN83d2G/v32ipNClRKgYv30onQlMZX1vCeZMjPsMMPl1mDpmbl0+N5BYo4S/ofzqJyS5hvwacEo0CCVDn/Qg==}
 
@@ -16277,6 +16344,51 @@ snapshots:
       log-update: 5.0.1
       sisteransi: 1.0.5
 
+  '@astrojs/compiler-binding-darwin-arm64@0.1.1':
+    optional: true
+
+  '@astrojs/compiler-binding-darwin-x64@0.1.1':
+    optional: true
+
+  '@astrojs/compiler-binding-linux-arm64-gnu@0.1.1':
+    optional: true
+
+  '@astrojs/compiler-binding-linux-arm64-musl@0.1.1':
+    optional: true
+
+  '@astrojs/compiler-binding-linux-x64-gnu@0.1.1':
+    optional: true
+
+  '@astrojs/compiler-binding-linux-x64-musl@0.1.1':
+    optional: true
+
+  '@astrojs/compiler-binding-wasm32-wasi@0.1.1':
+    dependencies:
+      '@napi-rs/wasm-runtime': 1.1.1
+    optional: true
+
+  '@astrojs/compiler-binding-win32-arm64-msvc@0.1.1':
+    optional: true
+
+  '@astrojs/compiler-binding-win32-x64-msvc@0.1.1':
+    optional: true
+
+  '@astrojs/compiler-binding@0.1.1':
+    optionalDependencies:
+      '@astrojs/compiler-binding-darwin-arm64': 0.1.1
+      '@astrojs/compiler-binding-darwin-x64': 0.1.1
+      '@astrojs/compiler-binding-linux-arm64-gnu': 0.1.1
+      '@astrojs/compiler-binding-linux-arm64-musl': 0.1.1
+      '@astrojs/compiler-binding-linux-x64-gnu': 0.1.1
+      '@astrojs/compiler-binding-linux-x64-musl': 0.1.1
+      '@astrojs/compiler-binding-wasm32-wasi': 0.1.1
+      '@astrojs/compiler-binding-win32-arm64-msvc': 0.1.1
+      '@astrojs/compiler-binding-win32-x64-msvc': 0.1.1
+
+  '@astrojs/compiler-rs@0.1.1':
+    dependencies:
+      '@astrojs/compiler-binding': 0.1.1
+
   '@astrojs/compiler@2.13.1': {}
 
   '@astrojs/compiler@3.0.0-beta.0': {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 16e289c7c4ed..5118fdb1187b 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -32,6 +32,8 @@ minimumReleaseAge: 4320
 minimumReleaseAgeExclude:
   # TODO: remove once more stable
   - '@flue/*'
+  - '@astrojs/compiler-rs'
+  - '@astrojs/compiler-binding*'
 peerDependencyRules:
   allowAny:
     - 'astro'