diff --git a/.changeset/fair-pets-crash.md b/.changeset/fair-pets-crash.md
new file mode 100644
index 000000000..75a03f602
--- /dev/null
+++ b/.changeset/fair-pets-crash.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/vite-plugin-svelte': major
+---
+
+Remove experimental "advanced raw queries" feature. Basic `File.svelte?raw` is still supported.
diff --git a/.changeset/shiny-hats-move.md b/.changeset/shiny-hats-move.md
new file mode 100644
index 000000000..3a6db49f7
--- /dev/null
+++ b/.changeset/shiny-hats-move.md
@@ -0,0 +1,6 @@
+---
+'@sveltejs/vite-plugin-svelte-inspector': patch
+'@sveltejs/vite-plugin-svelte': patch
+---
+
+use vite environment api internally
diff --git a/.changeset/thirty-roses-tell.md b/.changeset/thirty-roses-tell.md
new file mode 100644
index 000000000..9935da02e
--- /dev/null
+++ b/.changeset/thirty-roses-tell.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/vite-plugin-svelte': major
+---
+
+split preprocess and compile into separate plugins
diff --git a/.changeset/two-facts-sink.md b/.changeset/two-facts-sink.md
new file mode 100644
index 000000000..babffa5eb
--- /dev/null
+++ b/.changeset/two-facts-sink.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/vite-plugin-svelte': patch
+---
+
+deprecate `plugin.api.sveltePreprocess`
diff --git a/docs/advanced-usage.md b/docs/advanced-usage.md
index 4d7583db8..805d36572 100644
--- a/docs/advanced-usage.md
+++ b/docs/advanced-usage.md
@@ -7,6 +7,50 @@
 >
 > **Proceed with caution!**
 
+## transform svelte files with vite plugins
+
+vite-plugin-svelte uses 2 Vite plugins `vite-plugin-svelte:preprocess` and `vite-plugin-svelte:compile` to preprocess and compile input.
+The preprocess plugin uses `enforce: pre` but the compile plugin does not, giving you fine-grained control to add your own transforms
+
+```js
+function mySvelteTransform() {
+  const plugin = {
+    name: 'vite-plugin-my-svelte-transformer',
+    configResolved(c) {
+      // optional, use the exact same id filter as vite-plugin-svelte itself
+      const svelteIdFilter = c.plugins.find((p) => p.name === 'vite-plugin-svelte:config').api
+        .idFilter;
+      plugin.transform.filter.id = svelteIdFilter;
+    },
+    transform: {
+      // if you don't use vite-plugin-svelte's filter make sure to include your own here
+      filter: { id: /your id filter here/ },
+      async handler(code, id) {
+        const s = new MagicString(code);
+        // do your transforms with s
+        return {
+          code: s.toString(),
+          map: s.generateMap({ hires: 'boundary', includeContent: false })
+        };
+      }
+    }
+  };
+  // To add your transform in the correct place use `enforce` and `transform.order`
+
+  // before preprocess
+  plugin.enforce = 'pre';
+  plugin.transform.order = 'pre';
+
+  // after preprocess but before compile
+  plugin.transform.order = 'pre'; // leave plugin.enforce undefined
+
+  // after compile
+  plugin.transform.order = 'post'; // leave plugin.enforce undefined
+
+  return plugin;
+}
+```
+
 ## custom queries
 
 Vite supports using query parameters to request different outcomes for the same file.
@@ -19,103 +63,3 @@ The following schemes are supported by vite-plugin-svelte:
 //get .svelte file content as a string
 import content from 'File.svelte?raw';
 ```
-
-### experimental
-
-In addition to the plain .svelte source content, you can use special svelte queries.
-
-> These svelte subqueries are experimental, availability, syntax and output format may change
-
-#### raw&svelte
-
-```js
-//get output of svelte.preprocess code as string
-import preprocessed from 'File.svelte?raw&svelte&type=preprocessed';
-```
-
-```js
-//get output of svelte.compile js.code as string
-import script from 'File.svelte?raw&svelte&type=script';
-```
-
-```js
-//get output of svelte.compile css.code as string
-import style from 'File.svelte?raw&svelte&type=style';
-```
-
-##### detail exports
-
-raw&svelte exports code string as default export, but also offers named exports if you need details
-
-```js
-//get output of svelte.preprocess
-import { code, map, dependencies } from 'File.svelte?raw&svelte&type=preprocessed';
-```
-
-```js
-//get output of svelte.compile js
-import { code, map, dependencies } from 'File.svelte?raw&svelte&type=script';
-```
-
-```js
-//get output of svelte.compile css
-import { code, map, dependencies } from 'File.svelte?raw&svelte&type=style';
-```
-
-```js
-//get everything in one go
-import * as all from 'File.svelte?raw&svelte&type=all';
-import {
-  source,
-  preprocessed,
-  dependencies,
-  js,
-  css,
-  ast,
-  normalizedFilename,
-  ssr,
-  lang,
-  warnings,
-  stats
-} from 'File.svelte?raw&svelte&type=all';
-```
-
-#### direct&svelte
-
-```html
-<!-- load and execute component script -->
-<script type="application/javascript" src="File.svelte?direct&svelte&type=script&lang.js" />
-<!-- embed component style as css -->
-<link rel="stylesheet" type="text/css" href="File.svelte?direct&svelte&type=style&lang.css" />
-```
-
-#### sourcemap
-
-add `&sourcemap` to `?(raw|direct)&svelte&type=(script|style|all)` queries to include sourcemaps (inline for direct)
-
-#### compilerOptions
-
-?raw and ?direct use default compilerOptions, even if you have different values in your svelte.config.js:
-
-```js
-const compilerOptions = {
-  dev: false,
-  generate: 'client',
-  css: 'external'
-};
-```
-
-to get output with different compilerOptions, append them as json like this:
-
-```js
-//get ssr output of svelte.compile js as {code, map, dependencies}
-import script from 'File.svelte?raw&svelte&type=script&compilerOptions={"generate":"server"}';
-```
-
-only a subset of compilerOptions is supported
-
-- generate
-- dev
-- css
-- customElement
-- immutable
diff --git a/docs/faq.md b/docs/faq.md
index 2f9b334a3..b49422155 100644
--- a/docs/faq.md
+++ b/docs/faq.md
@@ -82,19 +82,7 @@ However, `cssHash` is respected in production builds as HMR is a dev-only featur
 
 ### How do I add a Svelte preprocessor from a Vite plugin?
 
-If you are building a Vite plugin that transforms CSS or JS, you can add a `api.sveltePreprocess: PreprocessorGroup` to your Vite plugin definition and it will be added to the list of Svelte preprocessors used at runtime.
-
-```js
-const vitePluginCoolCss = {
-  name: 'vite-plugin-coolcss',
-  api: {
-    sveltePreprocess: {
-      /* your PreprocessorGroup here */
-    }
-  }
-  /*... your cool css plugin implementation here .. */
-};
-```
+You don't have to anymore. See [advanced usage](advanced-usage.md) for examples how to put transform hooks before or after Svelte preprocess or compile
 
 ### What is going on with Vite and `Pre-bundling dependencies:`?
 
diff --git a/packages/e2e-tests/autoprefixer-browerslist/src/main.js b/packages/e2e-tests/autoprefixer-browerslist/src/main.js
index 47818da0c..071c75dc7 100644
--- a/packages/e2e-tests/autoprefixer-browerslist/src/main.js
+++ b/packages/e2e-tests/autoprefixer-browerslist/src/main.js
@@ -1,7 +1,3 @@
 import App from './App.svelte';
-
-if (App.toString().startsWith('class ')) {
-	new App({ target: document.body });
-} else {
-	import('svelte').then(({ mount }) => mount(App, { target: document.body }));
-}
+import { mount } from 'svelte';
+mount(App, { target: document.body });
diff --git a/packages/e2e-tests/configfile-custom/svelte.config.ts b/packages/e2e-tests/configfile-custom/svelte.config.ts
new file mode 100644
index 000000000..e92845e0b
--- /dev/null
+++ b/packages/e2e-tests/configfile-custom/svelte.config.ts
@@ -0,0 +1,2 @@
+console.log('default svelte config loaded');
+export default {};
diff --git a/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/preprocessed.txt b/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/preprocessed.txt
deleted file mode 100644
index a6320b265..000000000
--- a/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/preprocessed.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-<script lang="ts">
-	export let name: string;
-	let clicks = 0;
-</script>
-
-<button
-	on:click={() => {
-		clicks++;
-	}}>{name} clicks: {clicks}</button
->
-
-<style lang="scss">button {
-  color: #000099;
-}</style>
diff --git a/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/ssr-preprocessed.txt b/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/ssr-preprocessed.txt
deleted file mode 100644
index a6320b265..000000000
--- a/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/ssr-preprocessed.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-<script lang="ts">
-	export let name: string;
-	let clicks = 0;
-</script>
-
-<button
-	on:click={() => {
-		clicks++;
-	}}>{name} clicks: {clicks}</button
->
-
-<style lang="scss">button {
-  color: #000099;
-}</style>
diff --git a/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/style.txt b/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/style.txt
deleted file mode 100644
index 2e590fb1d..000000000
--- a/packages/e2e-tests/import-queries/__tests__/__snapshots__/svelte-5/style.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-button.svelte-d8vj6a {
-  color: #000099;
-}
\ No newline at end of file
diff --git a/packages/e2e-tests/import-queries/__tests__/import-queries.spec.ts b/packages/e2e-tests/import-queries/__tests__/import-queries.spec.ts
index 74c680808..3ee27dadc 100644
--- a/packages/e2e-tests/import-queries/__tests__/import-queries.spec.ts
+++ b/packages/e2e-tests/import-queries/__tests__/import-queries.spec.ts
@@ -1,4 +1,4 @@
-import { browserLogs, fetchFromPage, getText, isBuild, testDir } from '~utils';
+import { browserLogs, getText, isBuild, testDir } from '~utils';
 import { createServer, ViteDevServer } from 'vite';
 import { VERSION } from 'svelte/compiler';
 
@@ -22,114 +22,6 @@ describe('raw', () => {
 		const result = await getText('#raw');
 		await expect(result).toMatchFileSnapshot(snapshotFilename('raw'));
 	});
-
-	test('Dummy.svelte?raw&svelte&type=preprocessed', async () => {
-		const result = await getText('#preprocessed');
-		await expect(result).toMatchFileSnapshot(snapshotFilename('preprocessed'));
-	});
-
-	test('Dummy.svelte?raw&svelte&type=script', async () => {
-		const result = await getText('#script');
-		expect(result).toContain('export default function Dummy');
-	});
-
-	test('Dummy.svelte?raw&svelte&type=script&compilerOptions={"customElement":true}', async () => {
-		const result = await getText('#wcScript');
-		expect(result).toContain('$.create_custom_element(Dummy,');
-	});
-
-	test('Dummy.svelte?raw&svelte&type=style', async () => {
-		const result = await getText('#style');
-		await expect(result).toMatchFileSnapshot(snapshotFilename('style'));
-	});
-
-	test('Dummy.svelte?raw&svelte&type=all&sourcemap', async () => {
-		const result = JSON.parse(await getText('#all'));
-		expect(result.ast).toBeDefined();
-		expect(result.js).toBeDefined();
-		expect(result.js.code).toBeDefined();
-		expect(result.js.map).toBeDefined();
-		expect(result.css).toBeDefined();
-		expect(result.css.code).toBeDefined();
-		expect(result.css.map).toBeDefined();
-		expect(result.preprocessed).toBeDefined();
-		expect(result.preprocessed.code).toBeDefined();
-		expect(result.preprocessed.map).toBeDefined();
-	});
-
-	describe.runIf(!isBuild)('mixed exports', () => {
-		test('Dummy.svelte?raw&svelte&type=preprocessed', async () => {
-			const module = await fetchFromPage('src/Dummy.svelte?raw&svelte&type=preprocessed').then(
-				(res) => res.text()
-			);
-			expect(module).toContain('export const code="<script lang=\\"ts\\">');
-			expect(module).toContain('export const map={');
-			expect(module).toContain('export const dependencies=[]');
-			expect(module).toContain('export default code');
-		});
-		test('Dummy.svelte?raw&svelte&type=style', async () => {
-			const module = await fetchFromPage('src/Dummy.svelte?raw&svelte&type=style').then((res) =>
-				res.text()
-			);
-			expect(module).toContain('export const code="button.');
-			expect(module).toContain('export const hasGlobal=false');
-			expect(module).toContain('export const map={');
-			expect(module).toContain('export default code');
-		});
-		test('Dummy.svelte?raw&svelte&type=script', async () => {
-			const module = await fetchFromPage('src/Dummy.svelte?raw&svelte&type=script').then((res) =>
-				res.text()
-			);
-			expect(module).toContain('export const code="import');
-			expect(module).toContain('export const map={');
-			expect(module).toContain('export default code');
-		});
-		test('Dummy.svelte?raw&svelte&type=all', async () => {
-			const module = await fetchFromPage('src/Dummy.svelte?raw&svelte&type=all').then((res) =>
-				res.text()
-			);
-			expect(module).toContain('export const ast={"html":');
-			expect(module).toContain('export const css={"code":"button');
-			expect(module).toContain('export const dependencies=[]');
-			expect(module).toContain('export const js={"code":"import ');
-			expect(module).toContain('export const lang="ts"');
-			expect(module).toContain('export const metadata={"runes":false}');
-			expect(module).toContain('export const normalizedFilename="/src/Dummy.svelte"');
-			expect(module).toContain('export const preprocessed={"code":"<script lang=\\"ts\\">');
-			expect(module).toContain('export const source="<script lang=\\"ts\\">');
-			expect(module).toContain('export const ssr=false');
-			expect(module).toContain('export const warnings=[]');
-		});
-	});
-});
-
-describe.runIf(!isBuild)('direct', () => {
-	test('Dummy.svelte?direct&svelte&type=style&sourcemap&lang.css', async () => {
-		const response = await fetchFromPage(
-			'src/Dummy.svelte?direct&svelte&type=style&sourcemap&lang.css',
-			{
-				headers: { Accept: 'text/css' }
-			}
-		);
-		expect(response.ok).toBe(true);
-		expect(response.headers.get('Content-Type')).toBe('text/css');
-		const css = await response.text();
-		expect(css).toContain('button.');
-		expect(css).toContain('/*# sourceMappingURL=data');
-	});
-	test('Dummy.svelte?direct&svelte&type=script&sourcemap&lang.js', async () => {
-		const response = await fetchFromPage(
-			'src/Dummy.svelte?direct&svelte&type=script&sourcemap&lang.js',
-			{
-				headers: { Accept: 'text/javascript' }
-			}
-		);
-		expect(response.ok).toBe(true);
-		expect(response.headers.get('Content-Type')).toMatch(/^(?:text|application)\/javascript$/);
-		const js = await response.text();
-		expect(js).toContain('export default function Dummy');
-		expect(js).toContain('//# sourceMappingURL=data');
-	});
 });
 
 describe.runIf(!isBuild)('ssrLoadModule', () => {
@@ -158,29 +50,4 @@ describe.runIf(!isBuild)('ssrLoadModule', () => {
 		const result = await ssrLoadDummy('?raw');
 		await expect(result).toMatchFileSnapshot(snapshotFilename('ssr-raw'));
 	});
-	test('?raw&svelte&type=preprocessed', async () => {
-		const result = await ssrLoadDummy('?raw&svelte&type=preprocessed');
-		await expect(result).toMatchFileSnapshot(snapshotFilename('ssr-preprocessed'));
-	});
-	test('?raw&svelte&type=script', async () => {
-		const result = await ssrLoadDummy('?raw&svelte&type=script');
-		expect(result).toContain('export default function Dummy');
-	});
-	test('?raw&svelte&type=script&compilerOptions={"customElement":true}', async () => {
-		const result = await ssrLoadDummy(
-			'?raw&svelte&type=script&compilerOptions={"customElement":true}'
-		);
-		expect(result).toContain('$.create_custom_element(Dummy,');
-	});
-	test('?raw&svelte&type=style', async () => {
-		const result = await ssrLoadDummy('?raw&svelte&type=style');
-		expect(result).toContain('button.');
-	});
-	test('?inline&svelte&type=style&lang.css', async () => {
-		// Preload Dummy.svelte first so its CSS is processed in the module graph, otherwise loading
-		// its css inlined url directly will return the raw svelte file rather than the style
-		await ssrLoadDummy('');
-		const result = await ssrLoadDummy('?inline&svelte&type=style&lang.css');
-		expect(result).toContain('button.');
-	});
 });
diff --git a/packages/e2e-tests/preprocess-with-vite/__tests__/preprocess-with-vite.spec.ts b/packages/e2e-tests/preprocess-with-vite/__tests__/preprocess-with-vite.spec.ts
index b6bc00da4..11bcf5028 100644
--- a/packages/e2e-tests/preprocess-with-vite/__tests__/preprocess-with-vite.spec.ts
+++ b/packages/e2e-tests/preprocess-with-vite/__tests__/preprocess-with-vite.spec.ts
@@ -1,4 +1,4 @@
-import { getColor, getText, browserLogs } from '~utils';
+import { getColor, getText, browserLogs, getEl } from '~utils';
 import { expect } from 'vitest';
 
 test('should render App', async () => {
@@ -14,3 +14,20 @@ test('should not mangle code from esbuild pure annotations', async () => {
 	expect(browserLogs.some((log) => log.startsWith('pure test 1'))).toBe(true);
 	expect(browserLogs.some((log) => log.startsWith('pure test 2'))).toBe(true);
 });
+
+test('should apply transforms from preprocessors in the right order', async () => {
+	const ol = await getEl('#transforms-list');
+	expect(ol).toBeDefined();
+	const items = await ol.$$('li');
+	const texts = await Promise.all(items.map((l) => l.textContent()));
+	expect(texts[0]).toBe(
+		'before svelte preprocessors: vite-plugin (enforce: pre) transform (order: pre)'
+	);
+	expect(texts[1]).toBe('vite-plugin-svelte:preprocess: preprocessor from config');
+	expect(texts[2]).toBe(
+		'vite-plugin-svelte:preprocess: preprocessor from vitePlugin.api.sveltePreproess'
+	);
+	expect(texts[3]).toBe('after svelte preprocessors: vite-plugin (default) transform (default)');
+	expect(texts[4]).toBe('after svelte compile: vite-plugin (default) transform (order: post)');
+	expect(texts.length).toBe(5);
+});
diff --git a/packages/e2e-tests/preprocess-with-vite/package.json b/packages/e2e-tests/preprocess-with-vite/package.json
index 8fe552b95..24dfcf148 100644
--- a/packages/e2e-tests/preprocess-with-vite/package.json
+++ b/packages/e2e-tests/preprocess-with-vite/package.json
@@ -10,6 +10,7 @@
   "devDependencies": {
     "@sveltejs/vite-plugin-svelte": "workspace:^",
     "@tsconfig/svelte": "^5.0.4",
+    "magic-string": "^0.30.17",
     "sass": "^1.89.2",
     "stylus": "^0.64.0",
     "svelte": "^5.34.9",
diff --git a/packages/e2e-tests/preprocess-with-vite/src/App.svelte b/packages/e2e-tests/preprocess-with-vite/src/App.svelte
index 44a388abc..6133f39f0 100644
--- a/packages/e2e-tests/preprocess-with-vite/src/App.svelte
+++ b/packages/e2e-tests/preprocess-with-vite/src/App.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
 	import Foo from './Foo.svelte';
 	import Bar from './Bar.svelte';
+	import Preprocess from './Preprocess.svelte';
 	export let hello: string;
 	const world: string = 'world'; // edit world and save to see hmr update
 	enum Baz {
@@ -15,6 +16,8 @@
 <Bar />
 <p id="enum">{qoox}</p>
 
+<Preprocess />
+
 <style lang="scss">
 	@use 'sass:color';
 	$blue: blue;
diff --git a/packages/e2e-tests/preprocess-with-vite/src/Preprocess.svelte b/packages/e2e-tests/preprocess-with-vite/src/Preprocess.svelte
new file mode 100644
index 000000000..51511c4df
--- /dev/null
+++ b/packages/e2e-tests/preprocess-with-vite/src/Preprocess.svelte
@@ -0,0 +1,4 @@
+<h2>order of preprocess transforms</h2>
+<ol id="transforms-list">
+	<!-- various transforms from vite config inject list items here-->
+</ol>
diff --git a/packages/e2e-tests/preprocess-with-vite/svelte.config.js b/packages/e2e-tests/preprocess-with-vite/svelte.config.js
deleted file mode 100644
index 198eac21b..000000000
--- a/packages/e2e-tests/preprocess-with-vite/svelte.config.js
+++ /dev/null
@@ -1,5 +0,0 @@
-import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
-
-export default {
-	preprocess: [vitePreprocess({ script: true })]
-};
diff --git a/packages/e2e-tests/preprocess-with-vite/vite.config.js b/packages/e2e-tests/preprocess-with-vite/vite.config.js
index d8a969594..62997f6ca 100644
--- a/packages/e2e-tests/preprocess-with-vite/vite.config.js
+++ b/packages/e2e-tests/preprocess-with-vite/vite.config.js
@@ -1,10 +1,116 @@
-import { svelte } from '@sveltejs/vite-plugin-svelte';
+import { svelte, vitePreprocess } from '@sveltejs/vite-plugin-svelte';
 import { defineConfig } from 'vite';
+import MagicString from 'magic-string';
+import * as vite from 'vite';
+const { rolldownVersion } = vite;
+
+function addListItemTransform(code, filename, value) {
+	const index = code.indexOf('</ol>');
+	if (index < 0) {
+		return;
+	}
+	const s = new MagicString(code);
+	s.prependLeft(index, `<li>${value}</li>\n`);
+	return {
+		code: s.toString(),
+		// rolldown doesn't work with decoded map
+		map: s[rolldownVersion ? 'generateMap' : 'generateDecodedMap']({
+			hires: 'boundary',
+			file: filename,
+			includeContent: false
+		})
+	};
+}
+
+function beforePreprocess() {
+	return {
+		name: 'before-preprocess',
+		enforce: 'pre',
+		transform: {
+			order: 'pre',
+			filter: { id: { include: /Preprocess\.svelte/, exclude: /lang\.css$/ } },
+			async handler(code, id) {
+				return addListItemTransform(
+					code,
+					id,
+					'before svelte preprocessors: vite-plugin (enforce: pre) transform (order: pre)'
+				);
+			}
+		}
+	};
+}
+function afterPreprocess() {
+	return {
+		name: 'after-preprocess',
+		transform: {
+			filter: { id: { include: /Preprocess\.svelte/, exclude: /lang\.css$/ } },
+			async handler(code, id) {
+				return addListItemTransform(
+					code,
+					id,
+					'after svelte preprocessors: vite-plugin (default) transform (default)'
+				);
+			}
+		}
+	};
+}
+
+function afterCompile() {
+	return {
+		name: 'after-svelte',
+		transform: {
+			order: 'post',
+			filter: { id: { include: /Preprocess\.svelte/, exclude: /lang\.css$/ } },
+			async handler(code, id) {
+				return addListItemTransform(
+					code,
+					id,
+					'after svelte compile: vite-plugin (default) transform (order: post)'
+				);
+			}
+		}
+	};
+}
+
+function apiPreprocessor() {
+	return {
+		name: 'api-preprocess',
+		enforce: 'pre',
+		api: {
+			sveltePreprocess: {
+				markup: ({ content, filename }) =>
+					addListItemTransform(
+						content,
+						filename,
+						'vite-plugin-svelte:preprocess: preprocessor from vitePlugin.api.sveltePreproess'
+					)
+			}
+		}
+	};
+}
 
 export default defineConfig(({ command, mode }) => {
 	const isProduction = mode === 'production';
 	return {
-		plugins: [svelte()],
+		plugins: [
+			beforePreprocess(),
+			apiPreprocessor(),
+			svelte({
+				preprocess: [
+					vitePreprocess({ script: true }),
+					{
+						markup: ({ content, filename }) =>
+							addListItemTransform(
+								content,
+								filename,
+								'vite-plugin-svelte:preprocess: preprocessor from config'
+							)
+					}
+				]
+			}),
+			afterPreprocess(),
+			afterCompile()
+		],
 		build: {
 			minify: isProduction
 		}
diff --git a/packages/vite-plugin-svelte-inspector/src/index.js b/packages/vite-plugin-svelte-inspector/src/index.js
index 3b6978322..18a48a544 100644
--- a/packages/vite-plugin-svelte-inspector/src/index.js
+++ b/packages/vite-plugin-svelte-inspector/src/index.js
@@ -33,6 +33,10 @@ export function svelteInspector(options) {
 		apply: 'serve',
 		enforce: 'pre',
 
+		applyToEnvironment(env) {
+			return !disabled && env.config.consumer === 'client';
+		},
+
 		configResolved(config) {
 			viteConfig = config;
 			const environmentOptions = parseEnvironmentOptions(config);
@@ -43,7 +47,7 @@ export function svelteInspector(options) {
 			}
 
 			// Handle config from svelte.config.js through vite-plugin-svelte
-			const vps = config.plugins.find((p) => p.name === 'vite-plugin-svelte');
+			const vps = config.plugins.find((p) => p.name === 'vite-plugin-svelte:config');
 			const configFileOptions = vps?.api?.options?.inspector;
 
 			// vite-plugin-svelte can only pass options through it's `api` instead of `options`.
@@ -69,42 +73,53 @@ export function svelteInspector(options) {
 				base: config.base?.replace(/\/$/, '') || ''
 			};
 		},
-
-		async resolveId(importee, _, options) {
-			if (options?.ssr || disabled) {
-				return;
-			}
-			if (importee.startsWith('virtual:svelte-inspector-options')) {
-				return importee;
-			} else if (importee.startsWith('virtual:svelte-inspector-path:')) {
-				return importee.replace('virtual:svelte-inspector-path:', inspectorPath);
+		resolveId: {
+			filter: {
+				id: /^virtual:svelte-inspector-/
+			},
+			async handler(id) {
+				if (disabled) {
+					return;
+				}
+				if (id === 'virtual:svelte-inspector-options') {
+					return id;
+				} else if (id.startsWith('virtual:svelte-inspector-path:')) {
+					return id.replace('virtual:svelte-inspector-path:', inspectorPath);
+				}
 			}
 		},
-
-		async load(id, options) {
-			if (options?.ssr || disabled) {
-				return;
-			}
-			if (id === 'virtual:svelte-inspector-options') {
-				return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
-			} else if (id.startsWith(inspectorPath)) {
-				// read file ourselves to avoid getting shut out by vites fs.allow check
-				const file = cleanUrl(id);
-				if (fs.existsSync(id)) {
-					return await fs.promises.readFile(file, 'utf-8');
-				} else {
-					viteConfig.logger.error(
-						`[vite-plugin-svelte-inspector] failed to find svelte-inspector: ${id}`
-					);
+		load: {
+			filter: {
+				id: {
+					include: [`${inspectorPath}/**`, /^virtual:svelte-inspector-options$/],
+					exclude: [/style&lang\.css$/]
+				}
+			},
+			async handler(id) {
+				if (disabled) {
+					return;
+				}
+				if (id === 'virtual:svelte-inspector-options') {
+					return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
+				} else if (id.startsWith(inspectorPath)) {
+					// read file ourselves to avoid getting shut out by vites fs.allow check
+					const file = cleanUrl(id);
+					if (fs.existsSync(id)) {
+						return await fs.promises.readFile(file, 'utf-8');
+					} else {
+						viteConfig.logger.error(
+							`[vite-plugin-svelte-inspector] failed to find svelte-inspector: ${id}`
+						);
+					}
 				}
 			}
 		},
-
-		transform(code, id, options) {
-			if (options?.ssr || disabled) {
-				return;
-			}
-			if (id.includes('vite/dist/client/client.mjs')) {
+		transform: {
+			filter: { id: /vite\/dist\/client\/client\.mjs(?:\?|$)/ },
+			handler(code) {
+				if (disabled) {
+					return;
+				}
 				return { code: `${code}\nimport('virtual:svelte-inspector-path:load-inspector.js')` };
 			}
 		}
diff --git a/packages/vite-plugin-svelte/src/handle-hot-update.js b/packages/vite-plugin-svelte/src/handle-hot-update.js
deleted file mode 100644
index 82758e55a..000000000
--- a/packages/vite-plugin-svelte/src/handle-hot-update.js
+++ /dev/null
@@ -1,145 +0,0 @@
-import { log, logCompilerWarnings } from './utils/log.js';
-import { toRollupError } from './utils/error.js';
-
-/**
- * Vite-specific HMR handling
- *
- * @param {Function} compileSvelte
- * @param {import('vite').HmrContext} ctx
- * @param {import('./types/id.d.ts').SvelteRequest} svelteRequest
- * @param {import('./utils/vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
- * @param {import('./types/options.d.ts').ResolvedOptions} options
- * @returns {Promise<import('vite').ModuleNode[] | void>}
- */
-export async function handleHotUpdate(compileSvelte, ctx, svelteRequest, cache, options) {
-	if (!cache.has(svelteRequest)) {
-		// file hasn't been requested yet (e.g. async component)
-		log.debug(
-			`handleHotUpdate called before initial transform for ${svelteRequest.id}`,
-			undefined,
-			'hmr'
-		);
-		return;
-	}
-	const { read, server, modules } = ctx;
-
-	const cachedJS = cache.getJS(svelteRequest);
-	const cachedCss = cache.getCSS(svelteRequest);
-
-	const content = await read();
-	/** @type {import('./types/compile.d.ts').CompileData} */
-	let compileData;
-	try {
-		compileData = await compileSvelte(svelteRequest, content, options);
-		cache.update(compileData);
-	} catch (e) {
-		cache.setError(svelteRequest, e);
-		throw toRollupError(e, options);
-	}
-
-	const affectedModules = [...modules];
-
-	const cssIdx = modules.findIndex((m) => m.id === svelteRequest.cssId);
-	if (cssIdx > -1) {
-		const cssUpdated = cssChanged(cachedCss, compileData.compiled.css);
-		if (!cssUpdated) {
-			log.debug(`skipping unchanged css for ${svelteRequest.cssId}`, undefined, 'hmr');
-			affectedModules.splice(cssIdx, 1);
-		}
-	}
-	const jsIdx = modules.findIndex((m) => m.id === svelteRequest.id);
-	if (jsIdx > -1) {
-		const jsUpdated = jsChanged(cachedJS, compileData.compiled.js, svelteRequest.filename);
-		if (!jsUpdated) {
-			log.debug(`skipping unchanged js for ${svelteRequest.id}`, undefined, 'hmr');
-			affectedModules.splice(jsIdx, 1);
-			// transform won't be called, log warnings here
-			logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
-		}
-	}
-
-	// TODO is this enough? see also: https://github.com/vitejs/vite/issues/2274
-	const ssrModulesToInvalidate = affectedModules.filter((m) => !!m.ssrTransformResult);
-	if (ssrModulesToInvalidate.length > 0) {
-		log.debug(
-			`invalidating modules ${ssrModulesToInvalidate.map((m) => m.id).join(', ')}`,
-			undefined,
-			'hmr'
-		);
-		ssrModulesToInvalidate.forEach((moduleNode) => server.moduleGraph.invalidateModule(moduleNode));
-	}
-	if (affectedModules.length > 0) {
-		log.debug(
-			`handleHotUpdate for ${svelteRequest.id} result: ${affectedModules
-				.map((m) => m.id)
-				.join(', ')}`,
-			undefined,
-			'hmr'
-		);
-	}
-	return affectedModules;
-}
-
-/**
- * @param {import('./types/compile.d.ts').Code | null} [prev]
- * @param {import('./types/compile.d.ts').Code | null} [next]
- * @returns {boolean}
- */
-function cssChanged(prev, next) {
-	return !isCodeEqual(prev?.code, next?.code);
-}
-
-/**
- * @param {import('./types/compile.d.ts').Code | null} [prev]
- * @param {import('./types/compile.d.ts').Code | null} [next]
- * @param {string} [filename]
- * @returns {boolean}
- */
-function jsChanged(prev, next, filename) {
-	const prevJs = prev?.code;
-	const nextJs = next?.code;
-	const isStrictEqual = isCodeEqual(prevJs, nextJs);
-	if (isStrictEqual) {
-		return false;
-	}
-	const isLooseEqual = isCodeEqual(normalizeJsCode(prevJs), normalizeJsCode(nextJs));
-	if (!isStrictEqual && isLooseEqual) {
-		log.debug(
-			`ignoring compiler output js change for ${filename} as it is equal to previous output after normalization`,
-			undefined,
-			'hmr'
-		);
-	}
-	return !isLooseEqual;
-}
-
-/**
- * @param {string} [prev]
- * @param {string} [next]
- * @returns {boolean}
- */
-function isCodeEqual(prev, next) {
-	if (!prev && !next) {
-		return true;
-	}
-	if ((!prev && next) || (prev && !next)) {
-		return false;
-	}
-	return prev === next;
-}
-
-/**
- * remove code that only changes metadata and does not require a js update for the component to keep working
- *
- * 1) add_location() calls. These add location metadata to elements, only used by some dev tools
- * 2) ... maybe more (or less) in the future
- *
- * @param {string} [code]
- * @returns {string | undefined}
- */
-function normalizeJsCode(code) {
-	if (!code) {
-		return code;
-	}
-	return code.replace(/\s*\badd_location\s*\([^)]*\)\s*;?/g, '');
-}
diff --git a/packages/vite-plugin-svelte/src/index.js b/packages/vite-plugin-svelte/src/index.js
index f0ecd1fc1..83e0cc720 100644
--- a/packages/vite-plugin-svelte/src/index.js
+++ b/packages/vite-plugin-svelte/src/index.js
@@ -1,36 +1,19 @@
-import fs from 'node:fs';
 import process from 'node:process';
+import { log } from './utils/log.js';
+import { configure } from './plugins/configure.js';
+import { preprocess } from './plugins/preprocess.js';
+import { compile } from './plugins/compile.js';
+import { loadCompiledCss } from './plugins/load-compiled-css.js';
+import { setupOptimizer } from './plugins/setup-optimizer.js';
+import { compileModule } from './plugins/compile-module.js';
 import { svelteInspector } from '@sveltejs/vite-plugin-svelte-inspector';
-import { handleHotUpdate } from './handle-hot-update.js';
-import { log, logCompilerWarnings } from './utils/log.js';
-import { createCompileSvelte } from './utils/compile.js';
-import {
-	buildIdFilter,
-	buildIdParser,
-	buildModuleIdFilter,
-	buildModuleIdParser
-} from './utils/id.js';
-import {
-	buildExtraViteConfig,
-	validateInlineOptions,
-	resolveOptions,
-	patchResolvedViteConfig,
-	preResolveOptions,
-	ensureConfigEnvironmentMainFields,
-	ensureConfigEnvironmentConditions
-} from './utils/options.js';
-import { ensureWatchedFile, setupWatchers } from './utils/watch.js';
-import { toRollupError } from './utils/error.js';
-import { saveSvelteMetadata } from './utils/optimizer.js';
-import { VitePluginSvelteCache } from './utils/vite-plugin-svelte-cache.js';
-import { loadRaw } from './utils/load-raw.js';
-import * as svelteCompiler from 'svelte/compiler';
-import { SVELTE_VIRTUAL_STYLE_ID_REGEX } from './utils/constants.js';
-import * as vite from 'vite';
-// @ts-expect-error rolldownVersion
-const { version: viteVersion, rolldownVersion } = vite;
+import { loadCustom } from './plugins/load-custom.js';
+import { hotUpdate } from './plugins/hot-update.js';
 
 /**
+ * returns a list of plugins to handle svelte files
+ * plugins are named `vite-plugin-svelte:<task>`
+ *
  * @param {Partial<import('./public.d.ts').Options>} [inlineOptions]
  * @returns {import('vite').Plugin[]}
  */
@@ -38,235 +21,21 @@ export function svelte(inlineOptions) {
 	if (process.env.DEBUG != null) {
 		log.setLevel('debug');
 	}
-	if (rolldownVersion) {
-		log.warn.once(
-			`!!! Support for rolldown-vite in vite-plugin-svelte is experimental (rolldown: ${rolldownVersion}, vite: ${viteVersion}) !!!
-			See https://github.com/sveltejs/vite-plugin-svelte/issues/1143 for a list of known issues and to report feedback.`.replace(
-				/\t+/g,
-				'\t'
-			)
-		);
-	}
-
-	validateInlineOptions(inlineOptions);
-	const cache = new VitePluginSvelteCache();
-	// updated in configResolved hook
-	/** @type {import('./types/id.d.ts').IdParser} */
-	let requestParser;
-	/** @type {import('./types/id.d.ts').ModuleIdParser} */
-	let moduleRequestParser;
-	/** @type {import('./types/options.d.ts').ResolvedOptions} */
-	let options;
-	/** @type {import('vite').ResolvedConfig} */
-	let viteConfig;
-	/** @type {import('./types/compile.d.ts').CompileSvelte} */
-	let compileSvelte;
-
-	/** @type {import('vite').Plugin} */
-	const compilePlugin = {
-		name: 'vite-plugin-svelte',
-		// make sure our resolver runs before vite internal resolver to resolve svelte field correctly
-		enforce: 'pre',
-		/** @type {import('./types/plugin-api.d.ts').PluginAPI} */
-		api: {},
-		async config(config, configEnv) {
-			// setup logger
-			if (process.env.DEBUG) {
-				log.setLevel('debug');
-			} else if (config.logLevel) {
-				log.setLevel(config.logLevel);
-			}
-			// @ts-expect-error temporarily lend the options variable until fixed in configResolved
-			options = await preResolveOptions(inlineOptions, config, configEnv);
-			// extra vite config
-			const extraViteConfig = await buildExtraViteConfig(options, config);
-			log.debug('additional vite config', extraViteConfig, 'config');
-			return extraViteConfig;
-		},
-
-		configEnvironment(name, config, opts) {
-			ensureConfigEnvironmentMainFields(name, config, opts);
-			// @ts-expect-error the function above should make `resolve.mainFields` non-nullable
-			config.resolve.mainFields.unshift('svelte');
-
-			ensureConfigEnvironmentConditions(name, config, opts);
-			// @ts-expect-error the function above should make `resolve.conditions` non-nullable
-			config.resolve.conditions.push('svelte');
-		},
-
-		async configResolved(config) {
-			options = resolveOptions(options, config, cache);
-			patchResolvedViteConfig(config, options);
-			const filter = buildIdFilter(options);
-			//@ts-expect-error transform defined below but filter not in type
-			compilePlugin.transform.filter = filter;
-			//@ts-expect-error load defined below but filter not in type
-			compilePlugin.load.filter = filter;
-
-			requestParser = buildIdParser(options);
-			compileSvelte = createCompileSvelte();
-			viteConfig = config;
-			// TODO deep clone to avoid mutability from outside?
-			compilePlugin.api.options = options;
-			log.debug('resolved options', options, 'config');
-			log.debug('filters', filter, 'config');
-		},
-
-		async buildStart() {
-			if (!options.prebundleSvelteLibraries) return;
-			const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
-			if (isSvelteMetadataChanged) {
-				// Force Vite to optimize again. Although we mutate the config here, it works because
-				// Vite's optimizer runs after `buildStart()`.
-				viteConfig.optimizeDeps.force = true;
-			}
-		},
-
-		configureServer(server) {
-			options.server = server;
-			setupWatchers(options, cache, requestParser);
-		},
-
-		load: {
-			async handler(id, opts) {
-				const ssr = !!opts?.ssr;
-				const svelteRequest = requestParser(id, !!ssr);
-				if (svelteRequest) {
-					const { filename, query, raw } = svelteRequest;
-					if (raw) {
-						const code = await loadRaw(svelteRequest, compileSvelte, options);
-						// prevent vite from injecting sourcemaps in the results.
-						return {
-							code,
-							map: {
-								mappings: ''
-							}
-						};
-					} else {
-						if (query.svelte && query.type === 'style') {
-							const cachedCss = cache.getCSS(svelteRequest);
-							if (cachedCss) {
-								const { hasGlobal, ...css } = cachedCss;
-								if (hasGlobal === false) {
-									// hasGlobal was added in svelte 5.26.0, so make sure it is boolean false
-									css.meta ??= {};
-									css.meta.vite ??= {};
-									css.meta.vite.cssScopeTo = [svelteRequest.filename, 'default'];
-								}
-								css.moduleType = 'css';
-
-								return css;
-							}
-						}
-						// prevent vite asset plugin from loading files as url that should be compiled in transform
-						if (viteConfig.assetsInclude(filename)) {
-							log.debug(`load returns raw content for ${filename}`, undefined, 'load');
-							return fs.readFileSync(filename, 'utf-8');
-						}
-					}
-				}
-			}
-		},
-
-		resolveId: {
-			// we don't use our generic filter here but a reduced one that only matches our virtual css
-			filter: { id: SVELTE_VIRTUAL_STYLE_ID_REGEX },
-			handler(id) {
-				// return cssId with root prefix so postcss pipeline of vite finds the directory correctly
-				// see https://github.com/sveltejs/vite-plugin-svelte/issues/14
-				log.debug(`resolveId resolved virtual css module ${id}`, undefined, 'resolve');
-				// TODO: do we have to repeat the dance for constructing the virtual id here? our transform added it that way
-				return id;
-			}
-		},
-
-		transform: {
-			async handler(code, id, opts) {
-				const ssr = !!opts?.ssr;
-				const svelteRequest = requestParser(id, ssr);
-				if (!svelteRequest || svelteRequest.query.type === 'style' || svelteRequest.raw) {
-					return;
-				}
-				let compileData;
-				try {
-					compileData = await compileSvelte(svelteRequest, code, options);
-				} catch (e) {
-					cache.setError(svelteRequest, e);
-					throw toRollupError(e, options);
-				}
-				logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
-				cache.update(compileData);
-				if (compileData.dependencies?.length) {
-					if (options.server) {
-						for (const dep of compileData.dependencies) {
-							ensureWatchedFile(options.server.watcher, dep, options.root);
-						}
-					} else if (options.isBuild && viteConfig.build.watch) {
-						for (const dep of compileData.dependencies) {
-							this.addWatchFile(dep);
-						}
-					}
-				}
-				return {
-					...compileData.compiled.js,
-					moduleType: 'js',
-					meta: {
-						vite: {
-							lang: compileData.lang
-						}
-					}
-				};
-			}
-		},
-
-		handleHotUpdate(ctx) {
-			if (!options.compilerOptions.hmr || !options.emitCss) {
-				return;
-			}
-			const svelteRequest = requestParser(ctx.file, false, ctx.timestamp);
-			if (svelteRequest) {
-				return handleHotUpdate(compileSvelte, ctx, svelteRequest, cache, options);
-			}
-		},
-		async buildEnd() {
-			await options.stats?.finishAll();
-		}
-	};
-
-	/** @type {import('vite').Plugin} */
-	const moduleCompilePlugin = {
-		name: 'vite-plugin-svelte-module',
-		enforce: 'post',
-		async configResolved() {
-			//@ts-expect-error transform defined below but filter not in type
-			moduleCompilePlugin.transform.filter = buildModuleIdFilter(options);
-			moduleRequestParser = buildModuleIdParser(options);
-		},
-		transform: {
-			async handler(code, id, opts) {
-				const ssr = !!opts?.ssr;
-				const moduleRequest = moduleRequestParser(id, ssr);
-				if (!moduleRequest) {
-					return;
-				}
-				try {
-					const compileResult = svelteCompiler.compileModule(code, {
-						dev: !viteConfig.isProduction,
-						generate: ssr ? 'server' : 'client',
-						filename: moduleRequest.filename
-					});
-					logCompilerWarnings(moduleRequest, compileResult.warnings, options);
-					return compileResult.js;
-				} catch (e) {
-					throw toRollupError(e, options);
-				}
-			}
-		}
-	};
-
-	/** @type {import('vite').Plugin[]} */
-	const plugins = [compilePlugin, moduleCompilePlugin, svelteInspector()];
-	return plugins;
+	/** @type {import('./types/plugin-api.js').PluginAPI} */
+	// @ts-expect-error initialize empty to guard against early use
+	const api = {}; // initialized by configure plugin, used in others
+	return [
+		{ name: 'vite-plugin-svelte' }, // marker for detection logic in other plugins that expect this name
+		configure(api, inlineOptions),
+		setupOptimizer(api),
+		loadCompiledCss(api),
+		loadCustom(api),
+		preprocess(api),
+		compile(api),
+		compileModule(api),
+		hotUpdate(api),
+		svelteInspector()
+	];
 }
 
 export { vitePreprocess } from './preprocess.js';
diff --git a/packages/vite-plugin-svelte/src/plugins/compile-module.js b/packages/vite-plugin-svelte/src/plugins/compile-module.js
new file mode 100644
index 000000000..2ae406cfe
--- /dev/null
+++ b/packages/vite-plugin-svelte/src/plugins/compile-module.js
@@ -0,0 +1,51 @@
+import { buildModuleIdFilter, buildModuleIdParser } from '../utils/id.js';
+import * as svelteCompiler from 'svelte/compiler';
+import { logCompilerWarnings } from '../utils/log.js';
+import { toRollupError } from '../utils/error.js';
+
+/**
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @returns {import('vite').Plugin}
+ */
+export function compileModule(api) {
+	/**
+	 * @type {import("../types/options.js").ResolvedOptions}
+	 */
+	let options;
+	/**
+	 * @type {import("../types/id.js").ModuleIdParser}
+	 */
+	let idParser;
+	/** @type {import('vite').Plugin} */
+	const plugin = {
+		name: 'vite-plugin-svelte:compile-module',
+		enforce: 'post',
+		async configResolved() {
+			options = api.options;
+			//@ts-expect-error transform defined below but filter not in type
+			plugin.transform.filter = buildModuleIdFilter(options);
+			idParser = buildModuleIdParser(options);
+		},
+		transform: {
+			async handler(code, id) {
+				const ssr = this.environment.config.consumer === 'server';
+				const moduleRequest = idParser(id, ssr);
+				if (!moduleRequest) {
+					return;
+				}
+				try {
+					const compileResult = svelteCompiler.compileModule(code, {
+						dev: !this.environment.config.isProduction,
+						generate: ssr ? 'server' : 'client',
+						filename: moduleRequest.filename
+					});
+					logCompilerWarnings(moduleRequest, compileResult.warnings, options);
+					return compileResult.js;
+				} catch (e) {
+					throw toRollupError(e, options);
+				}
+			}
+		}
+	};
+	return plugin;
+}
diff --git a/packages/vite-plugin-svelte/src/plugins/compile.js b/packages/vite-plugin-svelte/src/plugins/compile.js
new file mode 100644
index 000000000..a5bb21c66
--- /dev/null
+++ b/packages/vite-plugin-svelte/src/plugins/compile.js
@@ -0,0 +1,73 @@
+import { toRollupError } from '../utils/error.js';
+import { logCompilerWarnings } from '../utils/log.js';
+import { ensureWatchedFile } from '../utils/watch.js';
+
+/**
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @returns {import('vite').Plugin}
+ */
+export function compile(api) {
+	/**
+	 * @type {import("../types/options.js").ResolvedOptions}
+	 */
+	let options;
+
+	/**
+	 * @type {import("../types/compile.d.ts").CompileSvelte}
+	 */
+	let compileSvelte;
+	/** @type {import('vite').Plugin} */
+	const plugin = {
+		name: 'vite-plugin-svelte:compile',
+		configResolved() {
+			//@ts-expect-error defined below but filter not in type
+			plugin.transform.filter = api.idFilter;
+			options = api.options;
+			compileSvelte = api.compileSvelte;
+		},
+		transform: {
+			async handler(code, id) {
+				const ssr = this.environment.config.consumer === 'server';
+				const svelteRequest = api.idParser(id, ssr);
+				if (!svelteRequest || svelteRequest.raw) {
+					return;
+				}
+				const cache = api.getEnvironmentCache(this);
+				let compileData;
+				try {
+					const svelteMeta = this.getModuleInfo(id)?.meta?.svelte;
+					compileData = await compileSvelte(svelteRequest, code, options, svelteMeta?.preprocessed);
+				} catch (e) {
+					cache.setError(svelteRequest, e);
+					throw toRollupError(e, options);
+				}
+				if (compileData.compiled?.warnings) {
+					logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
+				}
+
+				cache.update(compileData);
+				if (compileData.dependencies?.length) {
+					if (options.server) {
+						for (const dep of compileData.dependencies) {
+							ensureWatchedFile(options.server.watcher, dep, options.root);
+						}
+					} else if (options.isBuild && this.environment.config.build.watch) {
+						for (const dep of compileData.dependencies) {
+							this.addWatchFile(dep);
+						}
+					}
+				}
+				return {
+					...compileData.compiled.js,
+					moduleType: 'js',
+					meta: {
+						vite: {
+							lang: compileData.lang
+						}
+					}
+				};
+			}
+		}
+	};
+	return plugin;
+}
diff --git a/packages/vite-plugin-svelte/src/plugins/configure.js b/packages/vite-plugin-svelte/src/plugins/configure.js
new file mode 100644
index 000000000..3797efd8c
--- /dev/null
+++ b/packages/vite-plugin-svelte/src/plugins/configure.js
@@ -0,0 +1,99 @@
+import process from 'node:process';
+import { isDebugNamespaceEnabled, log } from '../utils/log.js';
+import * as vite from 'vite';
+import { VitePluginSvelteCache } from '../utils/vite-plugin-svelte-cache.js';
+import { VitePluginSvelteStats } from '../utils/vite-plugin-svelte-stats.js';
+import {
+	buildExtraViteConfig,
+	validateInlineOptions,
+	resolveOptions,
+	preResolveOptions,
+	ensureConfigEnvironmentMainFields,
+	ensureConfigEnvironmentConditions
+} from '../utils/options.js';
+import { buildIdFilter, buildIdParser } from '../utils/id.js';
+import { createCompileSvelte } from '../utils/compile.js';
+
+// @ts-expect-error rolldownVersion
+const { version: viteVersion, rolldownVersion, perEnvironmentState } = vite;
+
+/**
+ * @param {Partial<import('../public.d.ts').Options>} [inlineOptions]
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @returns {import('vite').Plugin}
+ */
+export function configure(api, inlineOptions) {
+	if (rolldownVersion) {
+		log.warn.once(
+			`!!! Support for rolldown-vite in vite-plugin-svelte is experimental (rolldown: ${rolldownVersion}, vite: ${viteVersion}) !!!
+			See https://github.com/sveltejs/vite-plugin-svelte/issues/1143 for a list of known issues and to report feedback.`.replace(
+				/\t+/g,
+				'\t'
+			)
+		);
+	}
+
+	validateInlineOptions(inlineOptions);
+
+	/**
+	 * @type {import("../types/options.d.ts").PreResolvedOptions}
+	 */
+	let preOptions;
+
+	/** @type {import('vite').Plugin} */
+	return {
+		name: 'vite-plugin-svelte:config',
+		api,
+		// make sure it runs first
+		enforce: 'pre',
+		config: {
+			order: 'pre',
+			async handler(config, configEnv) {
+				// setup logger
+				if (process.env.DEBUG) {
+					log.setLevel('debug');
+				} else if (config.logLevel) {
+					log.setLevel(config.logLevel);
+				}
+
+				preOptions = await preResolveOptions(inlineOptions, config, configEnv);
+				// extra vite config
+				const extraViteConfig = await buildExtraViteConfig(preOptions, config);
+				log.debug('additional vite config', extraViteConfig, 'config');
+				return extraViteConfig;
+			}
+		},
+		configResolved: {
+			order: 'pre',
+			handler(config) {
+				const options = resolveOptions(preOptions, config);
+				api.options = options;
+				if (isDebugNamespaceEnabled('stats')) {
+					api.options.stats = new VitePluginSvelteStats();
+				}
+				//@ts-expect-error perEnvironmentState uses a wider type for PluginContext
+				api.getEnvironmentCache = perEnvironmentState((_env) => new VitePluginSvelteCache());
+				api.idFilter = buildIdFilter(options);
+
+				api.idParser = buildIdParser(options);
+				api.compileSvelte = createCompileSvelte();
+				log.debug('resolved options', api.options, 'config');
+			}
+		},
+
+		configEnvironment(name, config, opts) {
+			ensureConfigEnvironmentMainFields(name, config, opts);
+			// @ts-expect-error the function above should make `resolve.mainFields` non-nullable
+			config.resolve.mainFields.unshift('svelte');
+
+			ensureConfigEnvironmentConditions(name, config, opts);
+			// @ts-expect-error the function above should make `resolve.conditions` non-nullable
+			config.resolve.conditions.push('svelte');
+		},
+
+		configureServer(server) {
+			const { options } = api;
+			options.server = server;
+		}
+	};
+}
diff --git a/packages/vite-plugin-svelte/src/plugins/hot-update.js b/packages/vite-plugin-svelte/src/plugins/hot-update.js
new file mode 100644
index 000000000..8033f858a
--- /dev/null
+++ b/packages/vite-plugin-svelte/src/plugins/hot-update.js
@@ -0,0 +1,180 @@
+import { log } from '../utils/log.js';
+import { setupWatchers } from '../utils/watch.js';
+import { SVELTE_VIRTUAL_STYLE_ID_REGEX } from '../utils/constants.js';
+
+/**
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @returns {import('vite').Plugin}
+ */
+export function hotUpdate(api) {
+	/**
+	 * @type {import("../types/options.js").ResolvedOptions}
+	 */
+	let options;
+	/**
+	 * @type {import('../types/id.d.ts').IdParser}
+	 */
+	let idParser;
+
+	/**
+	 *
+	 * @type {Map<string|null,string>}
+	 */
+	const transformResultCache = new Map();
+
+	/** @type {import('vite').Plugin} */
+	const plugin = {
+		name: 'vite-plugin-svelte:hot-update',
+		enforce: 'post',
+		configResolved() {
+			options = api.options;
+			idParser = api.idParser;
+
+			// @ts-expect-error
+			plugin.transform.filter = {
+				id: {
+					// reinclude virtual styles to get their output
+					include: [...api.idFilter.id.include, SVELTE_VIRTUAL_STYLE_ID_REGEX],
+					exclude: [
+						// ignore files in node_modules, we don't hot update them
+						/\/node_modules\//,
+						// remove style exclusion
+						...api.idFilter.id.exclude.filter((filter) => filter !== SVELTE_VIRTUAL_STYLE_ID_REGEX)
+					]
+				}
+			};
+		},
+
+		applyToEnvironment(env) {
+			// we only handle updates for client components
+			// ssr frameworks have to handle updating/reloading themselves as v-p-s can't know what they prefer
+			const hmrEnabled = options.compilerOptions.hmr && options.emitCss;
+			return hmrEnabled && env.config.consumer === 'client';
+		},
+
+		configureServer(server) {
+			const clientEnvironment = Object.values(server.environments).find(
+				(e) => e.config.consumer === 'client'
+			);
+			if (clientEnvironment) {
+				setupWatchers(options, api.getEnvironmentCache({ environment: clientEnvironment }));
+			} else {
+				log.warn(
+					'No client environment found, not adding watchers for svelte config and preprocessor dependencies'
+				);
+			}
+		},
+
+		buildStart() {
+			transformResultCache.clear();
+		},
+
+		transform: {
+			order: 'post',
+			handler(code, id) {
+				transformResultCache.set(id, code);
+			}
+		},
+		hotUpdate: {
+			order: 'post',
+			async handler(ctx) {
+				const svelteRequest = idParser(ctx.file, false, ctx.timestamp);
+				if (svelteRequest) {
+					const { modules } = ctx;
+					const svelteModules = [];
+					const nonSvelteModules = [];
+					for (const mod of modules) {
+						if (transformResultCache.has(mod.id)) {
+							svelteModules.push(mod);
+						} else {
+							nonSvelteModules.push(mod);
+						}
+					}
+
+					if (svelteModules.length === 0) {
+						return; // nothing to do for us
+					}
+					const affectedModules = [];
+					const prevResults = svelteModules.map((m) => transformResultCache.get(m.id));
+					for (let i = 0; i < svelteModules.length; i++) {
+						const mod = svelteModules[i];
+						const prev = prevResults[i];
+						await this.environment.transformRequest(mod.url);
+						const next = transformResultCache.get(mod.id);
+						if (hasCodeChanged(prev, next, mod.id)) {
+							affectedModules.push(mod);
+						} else {
+							log.debug(
+								`skipping hot update for ${mod.id} because result is unchanged`,
+								undefined,
+								'hmr'
+							);
+						}
+					}
+					log.debug(
+						`hotUpdate for ${svelteRequest.id} result: [${affectedModules.map((m) => m.id).join(', ')}]`,
+						undefined,
+						'hmr'
+					);
+					return [...affectedModules, ...nonSvelteModules];
+				}
+			}
+		}
+	};
+
+	return plugin;
+}
+
+/**
+ * @param {string | undefined | null} prev
+ * @param {string | undefined | null} next
+ * @param {string | null} id
+ * @returns {boolean}
+ */
+function hasCodeChanged(prev, next, id) {
+	const isStrictEqual = nullSafeEqual(prev, next);
+	if (isStrictEqual) {
+		return false;
+	}
+	const isLooseEqual = nullSafeEqual(normalize(prev), normalize(next));
+	if (!isStrictEqual && isLooseEqual) {
+		log.debug(
+			`ignoring compiler output change for ${id} as it is equal to previous output after normalization`,
+			undefined,
+			'hmr'
+		);
+	}
+	return !isLooseEqual;
+}
+
+/**
+ * @param {string | null | undefined} prev
+ * @param {string | null | undefined} next
+ * @returns {boolean}
+ */
+function nullSafeEqual(prev, next) {
+	return (prev == null && next == null) || (prev != null && next != null && prev === next);
+}
+
+/**
+ * remove code that only changes metadata and does not require a js update for the component to keep working
+ *
+ * 1) add_location() calls. These add location metadata to elements, only used by some dev tools
+ * 2) vite query timestamps t=1235345.
+ *
+ * @param {string | null | undefined } code
+ * @returns {string | null | undefined}
+ */
+function normalize(code) {
+	if (code == null) {
+		return code;
+	}
+
+	return (
+		code
+			// svelte5 add_location line numbers argument
+			.replace(/(\$\.add_locations\(.*), \[(\[[.[\], \d]+])]/g, '$1, []')
+			// vite import analysis timestamp queries
+			.replace(/[?&]t=\d+/g, '')
+	);
+}
diff --git a/packages/vite-plugin-svelte/src/plugins/load-compiled-css.js b/packages/vite-plugin-svelte/src/plugins/load-compiled-css.js
new file mode 100644
index 000000000..fc7ec9d61
--- /dev/null
+++ b/packages/vite-plugin-svelte/src/plugins/load-compiled-css.js
@@ -0,0 +1,46 @@
+import { log } from '../utils/log.js';
+import { SVELTE_VIRTUAL_STYLE_ID_REGEX } from '../utils/constants.js';
+
+const filter = { id: SVELTE_VIRTUAL_STYLE_ID_REGEX };
+
+/**
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @returns {import('vite').Plugin}
+ */
+export function loadCompiledCss(api) {
+	return {
+		name: 'vite-plugin-svelte:load-compiled-css',
+
+		resolveId: {
+			filter, // same filter in load to ensure minimal work
+			handler(id) {
+				log.debug(`resolveId resolved virtual css module ${id}`, undefined, 'resolve');
+				return id;
+			}
+		},
+		load: {
+			filter,
+			async handler(id) {
+				const ssr = this.environment.config.consumer === 'server';
+				const svelteRequest = api.idParser(id, ssr);
+				if (!svelteRequest) {
+					return;
+				}
+				const cache = api.getEnvironmentCache(this);
+				const cachedCss = cache.getCSS(svelteRequest);
+				if (cachedCss) {
+					const { hasGlobal, ...css } = cachedCss;
+					if (hasGlobal === false) {
+						// hasGlobal was added in svelte 5.26.0, so make sure it is boolean false
+						css.meta ??= {};
+						css.meta.vite ??= {};
+						// TODO is that slice the best way to get the filename without parsing the id?
+						css.meta.vite.cssScopeTo = [id.slice(0, id.lastIndexOf('?')), 'default'];
+					}
+					css.moduleType = 'css';
+					return css;
+				}
+			}
+		}
+	};
+}
diff --git a/packages/vite-plugin-svelte/src/plugins/load-custom.js b/packages/vite-plugin-svelte/src/plugins/load-custom.js
new file mode 100644
index 000000000..0e32bba49
--- /dev/null
+++ b/packages/vite-plugin-svelte/src/plugins/load-custom.js
@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import { log } from '../utils/log.js';
+
+/**
+ * if svelte config includes files that vite treats as assets (e.g. .svg)
+ * we have to manually load them to avoid getting urls
+ *
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @returns {import('vite').Plugin}
+ */
+export function loadCustom(api) {
+	/** @type {import('vite').Plugin} */
+	const plugin = {
+		name: 'vite-plugin-svelte:load-custom',
+		enforce: 'pre', // must come before vites own asset handling or custom extensions like .svg won't work
+		configResolved() {
+			//@ts-expect-error load defined below but filter not in type
+			plugin.load.filter = api.idFilter;
+		},
+
+		load: {
+			//filter: is set in configResolved
+			async handler(id) {
+				const config = this.environment.config;
+				const ssr = config.consumer === 'server';
+				const svelteRequest = api.idParser(id, ssr);
+				if (svelteRequest) {
+					const { filename, query } = svelteRequest;
+					if (!query.url && config.assetsInclude(filename)) {
+						log.debug(
+							`loading ${filename} to prevent vite asset handling to turn it into a url by default`,
+							undefined,
+							'load'
+						);
+						return fs.readFileSync(filename, 'utf-8');
+					}
+				}
+			}
+		}
+	};
+	return plugin;
+}
diff --git a/packages/vite-plugin-svelte/src/plugins/preprocess.js b/packages/vite-plugin-svelte/src/plugins/preprocess.js
new file mode 100644
index 000000000..ce05b6ce8
--- /dev/null
+++ b/packages/vite-plugin-svelte/src/plugins/preprocess.js
@@ -0,0 +1,133 @@
+import { toRollupError } from '../utils/error.js';
+import { mapToRelative } from '../utils/sourcemaps.js';
+import * as svelte from 'svelte/compiler';
+import { log } from '../utils/log.js';
+import { arraify } from '../utils/options.js';
+
+/**
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @returns {import('vite').Plugin}
+ */
+export function preprocess(api) {
+	/**
+	 * @type {import("../types/options.js").ResolvedOptions}
+	 */
+	let options;
+
+	/**
+	 * @type {import("../types/compile.d.ts").PreprocessSvelte}
+	 */
+	let preprocessSvelte;
+	/** @type {import('vite').Plugin} */
+	const plugin = {
+		name: 'vite-plugin-svelte:preprocess',
+		enforce: 'pre',
+		configResolved(c) {
+			//@ts-expect-error defined below but filter not in type
+			plugin.transform.filter = api.idFilter;
+			options = api.options;
+			if (arraify(options.preprocess).length > 0) {
+				preprocessSvelte = createPreprocessSvelte(options, c);
+			} else {
+				log.debug(
+					`disabling ${plugin.name} because no preprocessor is configured`,
+					undefined,
+					'preprocess'
+				);
+				delete plugin.transform;
+			}
+		},
+
+		transform: {
+			async handler(code, id) {
+				const cache = api.getEnvironmentCache(this);
+				const ssr = this.environment.config.consumer === 'server';
+				const svelteRequest = api.idParser(id, ssr);
+				if (!svelteRequest) {
+					return;
+				}
+				try {
+					return await preprocessSvelte(svelteRequest, code, options);
+				} catch (e) {
+					cache.setError(svelteRequest, e);
+					throw toRollupError(e, options);
+				}
+			}
+		}
+	};
+	return plugin;
+}
+/**
+ * @param {import("../types/options.js").ResolvedOptions} options
+ * @param {import("vite").ResolvedConfig} resolvedConfig
+ * @returns {import('../types/compile.d.ts').PreprocessSvelte}
+ */
+function createPreprocessSvelte(options, resolvedConfig) {
+	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
+	let stats;
+	/** @type {Array<import('svelte/compiler').PreprocessorGroup>} */
+	const preprocessors = arraify(options.preprocess);
+
+	for (const preprocessor of preprocessors) {
+		if (preprocessor.style && '__resolvedConfig' in preprocessor.style) {
+			preprocessor.style.__resolvedConfig = resolvedConfig;
+		}
+	}
+
+	/** @type {import('../types/compile.d.ts').PreprocessSvelte} */
+	return async function preprocessSvelte(svelteRequest, code, options) {
+		const { filename, ssr } = svelteRequest;
+
+		if (options.stats) {
+			if (options.isBuild) {
+				if (!stats) {
+					// build is either completely ssr or csr, create stats collector on first compile
+					// it is then finished in the buildEnd hook.
+					stats = options.stats.startCollection(`${ssr ? 'ssr' : 'dom'} preprocess`, {
+						logInProgress: () => false
+					});
+				}
+			} else {
+				// dev time ssr, it's a ssr request and there are no stats, assume new page load and start collecting
+				if (ssr && !stats) {
+					stats = options.stats.startCollection('ssr preprocess');
+				}
+				// stats are being collected but this isn't an ssr request, assume page loaded and stop collecting
+				if (!ssr && stats) {
+					stats.finish();
+					stats = undefined;
+				}
+				// TODO find a way to trace dom compile during dev
+				// problem: we need to call finish at some point but have no way to tell if page load finished
+				// also they for hmr updates too
+			}
+		}
+
+		let preprocessed;
+
+		if (preprocessors && preprocessors.length > 0) {
+			try {
+				const endStat = stats?.start(filename);
+				preprocessed = await svelte.preprocess(code, preprocessors, { filename }); // full filename here so postcss works
+				endStat?.();
+			} catch (e) {
+				e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ''}`;
+				throw e;
+			}
+
+			if (typeof preprocessed?.map === 'object') {
+				mapToRelative(preprocessed?.map, filename);
+			}
+			return /** @type {import('../types/compile.d.ts').PreprocessTransformOutput} */ {
+				code: preprocessed.code,
+				// @ts-expect-error
+				map: preprocessed.map,
+				meta: {
+					svelte: {
+						preprocessed
+					}
+				}
+			};
+		}
+	};
+}
diff --git a/packages/vite-plugin-svelte/src/utils/optimizer-plugins.js b/packages/vite-plugin-svelte/src/plugins/setup-optimizer.js
similarity index 54%
rename from packages/vite-plugin-svelte/src/utils/optimizer-plugins.js
rename to packages/vite-plugin-svelte/src/plugins/setup-optimizer.js
index d5cd7a259..3b1493997 100644
--- a/packages/vite-plugin-svelte/src/utils/optimizer-plugins.js
+++ b/packages/vite-plugin-svelte/src/plugins/setup-optimizer.js
@@ -1,9 +1,14 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import { readFileSync } from 'node:fs';
 import * as svelte from 'svelte/compiler';
-import { log } from './log.js';
-import { toESBuildError, toRollupError } from './error.js';
-import { safeBase64Hash } from './hash.js';
-import { normalize } from './id.js';
+import { log } from '../utils/log.js';
+import { toESBuildError, toRollupError } from '../utils/error.js';
+import { safeBase64Hash } from '../utils/hash.js';
+import { normalize } from '../utils/id.js';
+import * as vite from 'vite';
+// @ts-expect-error not typed on vite
+const { rolldownVersion } = vite;
 
 /**
  * @typedef {NonNullable<import('vite').DepOptimizationOptions['esbuildOptions']>} EsbuildOptions
@@ -13,14 +18,86 @@ import { normalize } from './id.js';
  * @typedef {NonNullable<import('vite').Rollup.Plugin>} RollupPlugin
  */
 
-export const optimizeSveltePluginName = 'vite-plugin-svelte:optimize';
-export const optimizeSvelteModulePluginName = 'vite-plugin-svelte-module:optimize';
+const optimizeSveltePluginName = 'vite-plugin-svelte:optimize';
+const optimizeSvelteModulePluginName = 'vite-plugin-svelte:optimize-module';
+
+/**
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @returns {import('vite').Plugin}
+ */
+export function setupOptimizer(api) {
+	/** @type {import('vite').ResolvedConfig} */
+	let viteConfig;
+
+	return {
+		name: 'vite-plugin-svelte:setup-optimizer',
+		apply: 'serve',
+		config() {
+			/** @type {import('vite').UserConfig['optimizeDeps']} */
+			const optimizeDeps = {
+				// Experimental Vite API to allow these extensions to be scanned and prebundled
+				extensions: ['.svelte']
+			};
+			// Add optimizer plugins to prebundle Svelte files.
+			// Currently, a placeholder as more information is needed after Vite config is resolved,
+			// the added plugins are patched in configResolved below
+			if (rolldownVersion) {
+				//@ts-expect-error rolldown types not finished
+				optimizeDeps.rollupOptions = {
+					plugins: [
+						placeholderRolldownOptimizerPlugin(optimizeSveltePluginName),
+						placeholderRolldownOptimizerPlugin(optimizeSvelteModulePluginName)
+					]
+				};
+			} else {
+				optimizeDeps.esbuildOptions = {
+					plugins: [
+						{ name: optimizeSveltePluginName, setup: () => {} },
+						{ name: optimizeSvelteModulePluginName, setup: () => {} }
+					]
+				};
+			}
+			return { optimizeDeps };
+		},
+		configResolved(c) {
+			viteConfig = c;
+			const optimizeDeps = c.optimizeDeps;
+			if (rolldownVersion) {
+				const plugins =
+					// @ts-expect-error not typed
+					optimizeDeps.rollupOptions?.plugins?.filter((p) =>
+						[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
+					) ?? [];
+				for (const plugin of plugins) {
+					patchRolldownOptimizerPlugin(plugin, api.options);
+				}
+			} else {
+				const plugins =
+					optimizeDeps.esbuildOptions?.plugins?.filter((p) =>
+						[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
+					) ?? [];
+				for (const plugin of plugins) {
+					patchESBuildOptimizerPlugin(plugin, api.options);
+				}
+			}
+		},
+		async buildStart() {
+			if (!api.options.prebundleSvelteLibraries) return;
+			const changed = await svelteMetadataChanged(viteConfig.cacheDir, api.options);
+			if (changed) {
+				// Force Vite to optimize again. Although we mutate the config here, it works because
+				// Vite's optimizer runs after `buildStart()`.
+				viteConfig.optimizeDeps.force = true;
+			}
+		}
+	};
+}
 
 /**
  * @param {EsbuildPlugin} plugin
  * @param {import('../types/options.d.ts').ResolvedOptions} options
  */
-export function patchESBuildOptimizerPlugin(plugin, options) {
+function patchESBuildOptimizerPlugin(plugin, options) {
 	const components = plugin.name === optimizeSveltePluginName;
 	const compileFn = components ? compileSvelte : compileSvelteModule;
 	const statsName = components ? 'prebundle library components' : 'prebundle library modules';
@@ -57,7 +134,7 @@ export function patchESBuildOptimizerPlugin(plugin, options) {
  * @param {RollupPlugin} plugin
  * @param {import('../types/options.d.ts').ResolvedOptions} options
  */
-export function patchRolldownOptimizerPlugin(plugin, options) {
+function patchRolldownOptimizerPlugin(plugin, options) {
 	const components = plugin.name === optimizeSveltePluginName;
 	const compileFn = components ? compileSvelte : compileSvelteModule;
 	const statsName = components ? 'prebundle library components' : 'prebundle library modules';
@@ -193,3 +270,71 @@ async function compileSvelteModule(options, { filename, code }, statsCollection)
 		moduleType: 'js'
 	};
 }
+
+// List of options that changes the prebundling result
+/** @type {(keyof import('../types/options.d.ts').ResolvedOptions)[]} */
+const PREBUNDLE_SENSITIVE_OPTIONS = [
+	'compilerOptions',
+	'configFile',
+	'experimental',
+	'extensions',
+	'ignorePluginPreprocessors',
+	'preprocess'
+];
+
+/**
+ * stores svelte metadata in cache dir and compares if it has changed
+ *
+ * @param {string} cacheDir
+ * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @returns {Promise<boolean>} Whether the Svelte metadata has changed
+ */
+async function svelteMetadataChanged(cacheDir, options) {
+	const svelteMetadata = generateSvelteMetadata(options);
+	const svelteMetadataPath = path.resolve(cacheDir, '_svelte_metadata.json');
+
+	const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
+		// Handle preprocessors
+		return typeof value === 'function' ? value.toString() : value;
+	});
+
+	/** @type {string | undefined} */
+	let existingSvelteMetadata;
+	try {
+		existingSvelteMetadata = await fs.readFile(svelteMetadataPath, 'utf8');
+	} catch {
+		// ignore
+	}
+
+	await fs.mkdir(cacheDir, { recursive: true });
+	await fs.writeFile(svelteMetadataPath, currentSvelteMetadata);
+	return currentSvelteMetadata !== existingSvelteMetadata;
+}
+
+/**
+ *
+ * @param {string} name
+ * @returns {import('vite').Rollup.Plugin}
+ */
+function placeholderRolldownOptimizerPlugin(name) {
+	return {
+		name,
+		options() {},
+		buildStart() {},
+		buildEnd() {},
+		transform: { filter: { id: /^$/ }, handler() {} }
+	};
+}
+
+/**
+ * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @returns {Partial<import('../types/options.d.ts').ResolvedOptions>}
+ */
+function generateSvelteMetadata(options) {
+	/** @type {Record<string, any>} */
+	const metadata = {};
+	for (const key of PREBUNDLE_SENSITIVE_OPTIONS) {
+		metadata[key] = options[key];
+	}
+	return metadata;
+}
diff --git a/packages/vite-plugin-svelte/src/types/compile.d.ts b/packages/vite-plugin-svelte/src/types/compile.d.ts
index 14a5a8f03..603446376 100644
--- a/packages/vite-plugin-svelte/src/types/compile.d.ts
+++ b/packages/vite-plugin-svelte/src/types/compile.d.ts
@@ -1,14 +1,31 @@
 import type { Processed, CompileResult } from 'svelte/compiler';
 import type { SvelteRequest } from './id.d.ts';
 import type { ResolvedOptions } from './options.d.ts';
-import type { CustomPluginOptionsVite } from 'vite';
+import type { CustomPluginOptionsVite, Rollup } from 'vite';
 
 export type CompileSvelte = (
 	svelteRequest: SvelteRequest,
 	code: string,
-	options: Partial<ResolvedOptions>
+	options: Partial<ResolvedOptions>,
+	preprocessed?: Processed
 ) => Promise<CompileData>;
 
+export type PreprocessSvelte = (
+	svelteRequest: SvelteRequest,
+	code: string,
+	options: Partial<ResolvedOptions>
+) => Promise<PreprocessTransformOutput | undefined>;
+
+export interface PreprocessTransformOutput {
+	code: string;
+	map: Rollup.SourceMapInput;
+	meta: {
+		svelte: {
+			preprocessed: Processed;
+		};
+	};
+}
+
 export interface Code {
 	code: string;
 	map?: any;
@@ -23,6 +40,7 @@ export interface Code {
 export interface CompileData {
 	filename: string;
 	normalizedFilename: string;
+	cssId: string;
 	lang: string;
 	compiled: CompileResult;
 	ssr: boolean | undefined;
diff --git a/packages/vite-plugin-svelte/src/types/id.d.ts b/packages/vite-plugin-svelte/src/types/id.d.ts
index cbd0d3ced..f8434c7e9 100644
--- a/packages/vite-plugin-svelte/src/types/id.d.ts
+++ b/packages/vite-plugin-svelte/src/types/id.d.ts
@@ -1,16 +1,9 @@
-import type { CompileOptions } from 'svelte/compiler';
-
-export type SvelteQueryTypes = 'style' | 'script' | 'preprocessed' | 'all';
+export type SvelteQueryTypes = 'style';
 
 export interface RequestQuery {
 	// our own
 	svelte?: boolean;
 	type?: SvelteQueryTypes;
-	sourcemap?: boolean;
-	compilerOptions?: Pick<
-		CompileOptions,
-		'generate' | 'dev' | 'css' | 'customElement' | 'immutable'
-	>;
 	// vite specific
 	url?: boolean;
 	raw?: boolean;
diff --git a/packages/vite-plugin-svelte/src/types/plugin-api.d.ts b/packages/vite-plugin-svelte/src/types/plugin-api.d.ts
index 36c42b6ae..bb89bc942 100644
--- a/packages/vite-plugin-svelte/src/types/plugin-api.d.ts
+++ b/packages/vite-plugin-svelte/src/types/plugin-api.d.ts
@@ -1,11 +1,18 @@
 import type { ResolvedOptions } from './options.d.ts';
+import type { IdFilter, IdParser } from './id.d.ts';
+import type { CompileSvelte } from './compile.d.ts';
+import type { Environment } from 'vite';
+// eslint-disable-next-line n/no-missing-import
+import { VitePluginSvelteCache } from '../utils/vite-plugin-svelte-cache.js';
+
+interface EnvContext {
+	environment: Environment;
+}
 
 export interface PluginAPI {
-	/**
-	 * must not be modified, should not be used outside of vite-plugin-svelte repo
-	 * @internal
-	 * @experimental
-	 */
-	options?: ResolvedOptions;
-	// TODO expose compile cache here so other utility plugins can use it
+	options: ResolvedOptions;
+	getEnvironmentCache: (arg: EnvContext) => VitePluginSvelteCache;
+	idFilter: IdFilter;
+	idParser: IdParser;
+	compileSvelte: CompileSvelte;
 }
diff --git a/packages/vite-plugin-svelte/src/utils/compile.js b/packages/vite-plugin-svelte/src/utils/compile.js
index f7999fe72..43d55ec35 100644
--- a/packages/vite-plugin-svelte/src/utils/compile.js
+++ b/packages/vite-plugin-svelte/src/utils/compile.js
@@ -2,10 +2,7 @@ import * as svelte from 'svelte/compiler';
 import { safeBase64Hash } from './hash.js';
 import { log } from './log.js';
 
-import {
-	checkPreprocessDependencies,
-	createInjectScopeEverythingRulePreprocessorGroup
-} from './preprocess.js';
+import { checkPreprocessDependencies } from './preprocess.js';
 import { mapToRelative } from './sourcemaps.js';
 import { enhanceCompileError } from './error.js';
 
@@ -21,9 +18,8 @@ const scriptLangRE =
 export function createCompileSvelte() {
 	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
 	let stats;
-	const devStylePreprocessor = createInjectScopeEverythingRulePreprocessorGroup();
 	/** @type {import('../types/compile.d.ts').CompileSvelte} */
-	return async function compileSvelte(svelteRequest, code, options) {
+	return async function compileSvelte(svelteRequest, code, options, preprocessed) {
 		const { filename, normalizedFilename, cssId, ssr, raw } = svelteRequest;
 		const { emitCss = true } = options;
 		/** @type {string[]} */
@@ -55,6 +51,7 @@ export function createCompileSvelte() {
 				// also they for hmr updates too
 			}
 		}
+
 		/** @type {import('svelte/compiler').CompileOptions} */
 		const compileOptions = {
 			...options.compilerOptions,
@@ -62,31 +59,7 @@ export function createCompileSvelte() {
 			generate: ssr ? 'server' : 'client'
 		};
 
-		if (compileOptions.hmr && options.emitCss) {
-			const hash = `s-${safeBase64Hash(normalizedFilename)}`;
-			compileOptions.cssHash = () => hash;
-		}
-
-		let preprocessed;
-		let preprocessors = options.preprocess;
-		if (!options.isBuild && options.emitCss && compileOptions.hmr) {
-			// inject preprocessor that ensures css hmr works better
-			if (!Array.isArray(preprocessors)) {
-				preprocessors = preprocessors
-					? [preprocessors, devStylePreprocessor]
-					: [devStylePreprocessor];
-			} else {
-				preprocessors = preprocessors.concat(devStylePreprocessor);
-			}
-		}
-		if (preprocessors) {
-			try {
-				preprocessed = await svelte.preprocess(code, preprocessors, { filename }); // full filename here so postcss works
-			} catch (e) {
-				e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ''}`;
-				throw e;
-			}
-
+		if (preprocessed) {
 			if (preprocessed.dependencies?.length) {
 				const checked = checkPreprocessDependencies(filename, preprocessed.dependencies);
 				if (checked.warnings.length) {
@@ -99,16 +72,19 @@ export function createCompileSvelte() {
 
 			if (preprocessed.map) compileOptions.sourcemap = preprocessed.map;
 		}
-		if (typeof preprocessed?.map === 'object') {
-			mapToRelative(preprocessed?.map, filename);
-		}
-		if (raw && svelteRequest.query.type === 'preprocessed') {
-			// @ts-expect-error shortcut
-			return /** @type {import('../types/compile.d.ts').CompileData} */ {
-				preprocessed: preprocessed ?? { code }
-			};
+
+		let finalCode = code;
+		if (compileOptions.hmr && options.emitCss) {
+			const hash = `s-${safeBase64Hash(normalizedFilename)}`;
+			compileOptions.cssHash = () => hash;
+			const closeStylePos = code.lastIndexOf('</style>');
+			if (closeStylePos > -1) {
+				// inject rule that forces compile to attach scope class to every node in the template
+				// this reduces the amount of js hot updates when editing css in .svelte files
+				finalCode = finalCode.slice(0, closeStylePos) + ' *{}' + finalCode.slice(closeStylePos);
+			}
 		}
-		const finalCode = preprocessed ? preprocessed.code : code;
+
 		const dynamicCompileOptions = await options?.dynamicCompileOptions?.({
 			filename,
 			code: finalCode,
@@ -145,7 +121,7 @@ export function createCompileSvelte() {
 				);
 			}
 		} catch (e) {
-			enhanceCompileError(e, code, preprocessors);
+			enhanceCompileError(e, code, options.preprocess);
 			throw e;
 		}
 
@@ -181,6 +157,7 @@ export function createCompileSvelte() {
 		return {
 			filename,
 			normalizedFilename,
+			cssId,
 			lang,
 			compiled,
 			ssr,
diff --git a/packages/vite-plugin-svelte/src/utils/constants.js b/packages/vite-plugin-svelte/src/utils/constants.js
index 20cfc1a3e..449a05246 100644
--- a/packages/vite-plugin-svelte/src/utils/constants.js
+++ b/packages/vite-plugin-svelte/src/utils/constants.js
@@ -30,7 +30,4 @@ export const DEFAULT_SVELTE_EXT = ['.svelte'];
 export const DEFAULT_SVELTE_MODULE_INFIX = ['.svelte.'];
 export const DEFAULT_SVELTE_MODULE_EXT = ['.js', '.ts'];
 
-export const SVELTE_VIRTUAL_STYLE_SUFFIX = '?svelte&type=style&lang.css';
-export const SVELTE_VIRTUAL_STYLE_ID_REGEX = new RegExp(
-	`${SVELTE_VIRTUAL_STYLE_SUFFIX.replace(/[?.]/g, '\\$&')}$`
-);
+export const SVELTE_VIRTUAL_STYLE_ID_REGEX = /[?&]svelte&type=style&lang.css$/;
diff --git a/packages/vite-plugin-svelte/src/utils/dependencies.js b/packages/vite-plugin-svelte/src/utils/dependencies.js
index 30caf5901..341bf3cd0 100644
--- a/packages/vite-plugin-svelte/src/utils/dependencies.js
+++ b/packages/vite-plugin-svelte/src/utils/dependencies.js
@@ -1,32 +1,3 @@
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import { findDepPkgJsonPath } from 'vitefu';
-
-/**
- * @typedef {{
- *  dir: string;
- *	pkg: Record<string, any>;
- * }} DependencyData
- */
-
-/**
- * @param {string} dep
- * @param {string} parent
- * @returns {Promise<DependencyData | undefined>}
- */
-export async function resolveDependencyData(dep, parent) {
-	const depDataPath = await findDepPkgJsonPath(dep, parent);
-	if (!depDataPath) return undefined;
-	try {
-		return {
-			dir: path.dirname(depDataPath),
-			pkg: JSON.parse(await fs.readFile(depDataPath, 'utf-8'))
-		};
-	} catch {
-		return undefined;
-	}
-}
-
 const COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD = [
 	'@lukeed/uuid',
 	'@playwright/test',
diff --git a/packages/vite-plugin-svelte/src/utils/id.js b/packages/vite-plugin-svelte/src/utils/id.js
index 9bf967673..90bd16d9e 100644
--- a/packages/vite-plugin-svelte/src/utils/id.js
+++ b/packages/vite-plugin-svelte/src/utils/id.js
@@ -5,7 +5,8 @@ import { log } from './log.js';
 import {
 	DEFAULT_SVELTE_EXT,
 	DEFAULT_SVELTE_MODULE_EXT,
-	DEFAULT_SVELTE_MODULE_INFIX
+	DEFAULT_SVELTE_MODULE_INFIX,
+	SVELTE_VIRTUAL_STYLE_ID_REGEX
 } from './constants.js';
 import { arraify } from './options.js';
 
@@ -179,13 +180,15 @@ export function buildIdFilter(options) {
 			.map(escapeRE)
 			.join('|')})(?:[?#]|$)`
 	);
-	const filter = {
+	return {
 		id: {
 			include: [extensionsRE, .../**@type {Array<string|RegExp>}*/ arraify(include)],
-			exclude: /**@type {Array<string|RegExp>}*/ arraify(exclude)
+			exclude: /**@type {Array<string|RegExp>}*/ [
+				SVELTE_VIRTUAL_STYLE_ID_REGEX, // exclude from regular pipeline, we load it in a separate plugin
+				...arraify(exclude)
+			]
 		}
 	};
-	return filter;
 }
 
 /**
diff --git a/packages/vite-plugin-svelte/src/utils/load-raw.js b/packages/vite-plugin-svelte/src/utils/load-raw.js
deleted file mode 100644
index f800f1b47..000000000
--- a/packages/vite-plugin-svelte/src/utils/load-raw.js
+++ /dev/null
@@ -1,125 +0,0 @@
-import fs from 'node:fs';
-import { toRollupError } from './error.js';
-import { log } from './log.js';
-
-/**
- * utility function to compile ?raw and ?direct requests in load hook
- *
- * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
- * @param {import('../types/compile.d.ts').CompileSvelte} compileSvelte
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {Promise<string>}
- */
-export async function loadRaw(svelteRequest, compileSvelte, options) {
-	const { id, filename, query } = svelteRequest;
-
-	// raw svelte subrequest, compile on the fly and return requested subpart
-	let compileData;
-	const source = fs.readFileSync(filename, 'utf-8');
-	try {
-		//avoid compileSvelte doing extra ssr stuff unless requested
-		svelteRequest.ssr = query.compilerOptions?.generate === 'server';
-		compileData = await compileSvelte(svelteRequest, source, {
-			...options,
-			// don't use dynamic vite-plugin-svelte defaults here to ensure stable result between ssr,dev and build
-			compilerOptions: {
-				dev: false,
-				css: 'external',
-				hmr: false,
-				...svelteRequest.query.compilerOptions
-			},
-			emitCss: true
-		});
-	} catch (e) {
-		throw toRollupError(e, options);
-	}
-	let result;
-	if (query.type === 'style') {
-		result = compileData.compiled.css ?? { code: '', map: null };
-	} else if (query.type === 'script') {
-		result = compileData.compiled.js;
-	} else if (query.type === 'preprocessed') {
-		result = compileData.preprocessed;
-	} else if (query.type === 'all' && query.raw) {
-		return allToRawExports(compileData, source);
-	} else {
-		throw new Error(
-			`invalid "type=${query.type}" in ${id}. supported are script, style, preprocessed, all`
-		);
-	}
-	if (query.direct) {
-		const supportedDirectTypes = ['script', 'style'];
-		if (!supportedDirectTypes.includes(query.type)) {
-			throw new Error(
-				`invalid "type=${
-					query.type
-				}" combined with direct in ${id}. supported are: ${supportedDirectTypes.join(', ')}`
-			);
-		}
-		log.debug(`load returns direct result for ${id}`, undefined, 'load');
-		let directOutput = result.code;
-		// @ts-expect-error might not be SourceMap but toUrl check should suffice
-		if (query.sourcemap && result.map?.toUrl) {
-			// @ts-expect-error toUrl might not exist
-			const map = `sourceMappingURL=${result.map.toUrl()}`;
-			if (query.type === 'style') {
-				directOutput += `\n\n/*# ${map} */\n`;
-			} else if (query.type === 'script') {
-				directOutput += `\n\n//# ${map}\n`;
-			}
-		}
-		return directOutput;
-	} else if (query.raw) {
-		log.debug(`load returns raw result for ${id}`, undefined, 'load');
-		return toRawExports(result);
-	} else {
-		throw new Error(`invalid raw mode in ${id}, supported are raw, direct`);
-	}
-}
-
-/**
- * turn compileData and source into a flat list of raw exports
- *
- * @param {import('../types/compile.d.ts').CompileData} compileData
- * @param {string} source
- */
-function allToRawExports(compileData, source) {
-	// flatten CompileData
-	/** @type {Partial<import('../types/compile.d.ts').CompileData & { source: string }>} */
-	const exports = {
-		...compileData,
-		...compileData.compiled,
-		source
-	};
-	delete exports.compiled;
-	delete exports.filename; // absolute path, remove to avoid it in output
-	return toRawExports(exports);
-}
-
-/**
- * turn object into raw exports.
- *
- * every prop is returned as a const export, and if prop 'code' exists it is additionally added as default export
- *
- * eg {'foo':'bar','code':'baz'} results in
- *
- *  ```js
- *  export const code='baz'
- *  export const foo='bar'
- *  export default code
- *  ```
- * @param {object} object
- * @returns {string}
- */
-function toRawExports(object) {
-	let exports =
-		Object.entries(object)
-			.filter(([_key, value]) => typeof value !== 'function') // preprocess output has a toString function that's enumerable
-			.sort(([a], [b]) => (a < b ? -1 : a === b ? 0 : 1))
-			.map(([key, value]) => `export const ${key}=${JSON.stringify(value)}`)
-			.join('\n') + '\n';
-	if (Object.prototype.hasOwnProperty.call(object, 'code')) {
-		exports += 'export default code\n';
-	}
-	return exports;
-}
diff --git a/packages/vite-plugin-svelte/src/utils/optimizer.js b/packages/vite-plugin-svelte/src/utils/optimizer.js
deleted file mode 100644
index 71aa57162..000000000
--- a/packages/vite-plugin-svelte/src/utils/optimizer.js
+++ /dev/null
@@ -1,53 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-
-// List of options that changes the prebundling result
-/** @type {(keyof import('../types/options.d.ts').ResolvedOptions)[]} */
-const PREBUNDLE_SENSITIVE_OPTIONS = [
-	'compilerOptions',
-	'configFile',
-	'experimental',
-	'extensions',
-	'ignorePluginPreprocessors',
-	'preprocess'
-];
-
-/**
- * @param {string} cacheDir
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {Promise<boolean>} Whether the Svelte metadata has changed
- */
-export async function saveSvelteMetadata(cacheDir, options) {
-	const svelteMetadata = generateSvelteMetadata(options);
-	const svelteMetadataPath = path.resolve(cacheDir, '_svelte_metadata.json');
-
-	const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
-		// Handle preprocessors
-		return typeof value === 'function' ? value.toString() : value;
-	});
-
-	/** @type {string | undefined} */
-	let existingSvelteMetadata;
-	try {
-		existingSvelteMetadata = await fs.readFile(svelteMetadataPath, 'utf8');
-	} catch {
-		// ignore
-	}
-
-	await fs.mkdir(cacheDir, { recursive: true });
-	await fs.writeFile(svelteMetadataPath, currentSvelteMetadata);
-	return currentSvelteMetadata !== existingSvelteMetadata;
-}
-
-/**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {Partial<import('../types/options.d.ts').ResolvedOptions>}
- */
-function generateSvelteMetadata(options) {
-	/** @type {Record<string, any>} */
-	const metadata = {};
-	for (const key of PREBUNDLE_SENSITIVE_OPTIONS) {
-		metadata[key] = options[key];
-	}
-	return metadata;
-}
diff --git a/packages/vite-plugin-svelte/src/utils/options.js b/packages/vite-plugin-svelte/src/utils/options.js
index 9c83a0edc..39a4a6bc0 100644
--- a/packages/vite-plugin-svelte/src/utils/options.js
+++ b/packages/vite-plugin-svelte/src/utils/options.js
@@ -5,11 +5,9 @@ const {
 	defaultServerMainFields,
 	defaultClientConditions,
 	defaultServerConditions,
-	normalizePath,
-	//@ts-expect-error rolldownVersion not in type
-	rolldownVersion
+	normalizePath
 } = vite;
-import { isDebugNamespaceEnabled, log } from './log.js';
+import { log } from './log.js';
 import { loadSvelteConfig } from './load-svelte-config.js';
 import {
 	DEFAULT_SVELTE_EXT,
@@ -20,12 +18,6 @@ import {
 } from './constants.js';
 
 import path from 'node:path';
-import {
-	optimizeSvelteModulePluginName,
-	optimizeSveltePluginName,
-	patchESBuildOptimizerPlugin,
-	patchRolldownOptimizerPlugin
-} from './optimizer-plugins.js';
 import { addExtraPreprocessors } from './preprocess.js';
 import deepmerge from 'deepmerge';
 import {
@@ -37,7 +29,6 @@ import {
 } from 'vitefu';
 
 import { isCommonDepWithoutSvelteField } from './dependencies.js';
-import { VitePluginSvelteStats } from './vite-plugin-svelte-stats.js';
 
 const allowedPluginOptions = new Set([
 	'include',
@@ -198,10 +189,9 @@ function mergeConfigs(...configs) {
  *
  * @param {import('../types/options.d.ts').PreResolvedOptions} preResolveOptions
  * @param {import('vite').ResolvedConfig} viteConfig
- * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
  * @returns {import('../types/options.d.ts').ResolvedOptions}
  */
-export function resolveOptions(preResolveOptions, viteConfig, cache) {
+export function resolveOptions(preResolveOptions, viteConfig) {
 	const css = preResolveOptions.emitCss ? 'external' : 'injected';
 	/** @type {Partial<import('../public.d.ts').Options>} */
 	const defaultOptions = {
@@ -230,10 +220,7 @@ export function resolveOptions(preResolveOptions, viteConfig, cache) {
 	addExtraPreprocessors(merged, viteConfig);
 	enforceOptionsForHmr(merged, viteConfig);
 	enforceOptionsForProduction(merged);
-	// mergeConfigs would mangle functions on the stats class, so do this afterwards
-	if (log.debug.enabled && isDebugNamespaceEnabled('stats')) {
-		merged.stats = new VitePluginSvelteStats(cache);
-	}
+
 	return merged;
 }
 
@@ -384,46 +371,6 @@ export async function buildExtraViteConfig(options, config) {
 		]
 	};
 
-	// handle prebundling for svelte files
-	if (options.prebundleSvelteLibraries) {
-		extraViteConfig.optimizeDeps = {
-			...extraViteConfig.optimizeDeps,
-			// Experimental Vite API to allow these extensions to be scanned and prebundled
-			extensions: options.extensions ?? ['.svelte']
-		};
-		// Add optimizer plugins to prebundle Svelte files.
-		// Currently a placeholder as more information is needed after Vite config is resolved,
-		// the added plugins are patched in `patchResolvedViteConfig()`
-		if (rolldownVersion) {
-			/**
-			 *
-			 * @param {string} name
-			 * @returns {import('vite').Rollup.Plugin}
-			 */
-			const placeholderRolldownOptimizerPlugin = (name) => ({
-				name,
-				options() {},
-				buildStart() {},
-				buildEnd() {},
-				transform: { filter: { id: /^$/ }, handler() {} }
-			});
-			//@ts-expect-error rolldown types not finished
-			extraViteConfig.optimizeDeps.rollupOptions = {
-				plugins: [
-					placeholderRolldownOptimizerPlugin(optimizeSveltePluginName),
-					placeholderRolldownOptimizerPlugin(optimizeSvelteModulePluginName)
-				]
-			};
-		} else {
-			extraViteConfig.optimizeDeps.esbuildOptions = {
-				plugins: [
-					{ name: optimizeSveltePluginName, setup: () => {} },
-					{ name: optimizeSvelteModulePluginName, setup: () => {} }
-				]
-			};
-		}
-	}
-
 	// enable hmrPartialAccept if not explicitly disabled
 	if (config.experimental?.hmrPartialAccept !== false) {
 		log.debug('enabling "experimental.hmrPartialAccept" in vite config', undefined, 'config');
@@ -607,38 +554,6 @@ function buildExtraConfigForSvelte(config) {
 	return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
 }
 
-/**
- * @param {import('vite').ResolvedConfig} viteConfig
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- */
-export function patchResolvedViteConfig(viteConfig, options) {
-	if (options.preprocess) {
-		for (const preprocessor of arraify(options.preprocess)) {
-			if (preprocessor.style && '__resolvedConfig' in preprocessor.style) {
-				preprocessor.style.__resolvedConfig = viteConfig;
-			}
-		}
-	}
-	if (rolldownVersion) {
-		const plugins =
-			// @ts-expect-error not typed
-			viteConfig.optimizeDeps.rollupOptions?.plugins?.filter((p) =>
-				[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
-			) ?? [];
-		for (const plugin of plugins) {
-			patchRolldownOptimizerPlugin(plugin, options);
-		}
-	} else {
-		const plugins =
-			viteConfig.optimizeDeps.esbuildOptions?.plugins?.filter((p) =>
-				[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
-			) ?? [];
-		for (const plugin of plugins) {
-			patchESBuildOptimizerPlugin(plugin, options);
-		}
-	}
-}
-
 /**
  * Mutates `config` to ensure `resolve.mainFields` is set. If unset, it emulates Vite's default fallback.
  * @param {string} name
diff --git a/packages/vite-plugin-svelte/src/utils/preprocess.js b/packages/vite-plugin-svelte/src/utils/preprocess.js
index 602c649b5..8ce174505 100644
--- a/packages/vite-plugin-svelte/src/utils/preprocess.js
+++ b/packages/vite-plugin-svelte/src/utils/preprocess.js
@@ -1,33 +1,6 @@
-import MagicString from 'magic-string';
 import { log } from './log.js';
-import path from 'node:path';
 import { normalizePath } from 'vite';
 
-/**
- * this appends a *{} rule to component styles to force the svelte compiler to add style classes to all nodes
- * That means adding/removing class rules from <style> node won't trigger js updates as the scope classes are not changed
- *
- * only used during dev with enabled css hmr
- *
- * @returns {import('svelte/compiler').PreprocessorGroup}
- */
-export function createInjectScopeEverythingRulePreprocessorGroup() {
-	return {
-		name: 'inject-scope-everything-rule',
-		style({ content, filename }) {
-			const s = new MagicString(content);
-			s.append(' *{}');
-			return {
-				code: s.toString(),
-				map: s.generateDecodedMap({
-					source: filename ? path.basename(filename) : undefined,
-					hires: true
-				})
-			};
-		}
-	};
-}
-
 /**
  * @param {import('../types/options.d.ts').ResolvedOptions} options
  * @param {import('vite').ResolvedConfig} config
@@ -42,28 +15,13 @@ function buildExtraPreprocessors(options, config) {
 	/** @type {import('svelte/compiler').PreprocessorGroup[]} */
 	const appendPreprocessors = [];
 
-	// @ts-expect-error not typed
-	const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p?.sveltePreprocess);
+	const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p.api?.sveltePreprocess);
 	if (pluginsWithPreprocessorsDeprecated.length > 0) {
 		log.warn(
-			`The following plugins use the deprecated 'plugin.sveltePreprocess' field. Please contact their maintainers and ask them to move it to 'plugin.api.sveltePreprocess': ${pluginsWithPreprocessorsDeprecated
+			`The following plugins use the deprecated 'plugin.api.sveltePreprocess' field. Please contact their maintainers and ask them to use a vite plugin transform instead: ${pluginsWithPreprocessorsDeprecated
 				.map((p) => p.name)
 				.join(', ')}`
 		);
-		// patch plugin to avoid breaking
-		pluginsWithPreprocessorsDeprecated.forEach((p) => {
-			if (!p.api) {
-				p.api = {};
-			}
-			if (p.api.sveltePreprocess === undefined) {
-				// @ts-expect-error not typed
-				p.api.sveltePreprocess = p.sveltePreprocess;
-			} else {
-				log.error(
-					`ignoring plugin.sveltePreprocess of ${p.name} because it already defined plugin.api.sveltePreprocess.`
-				);
-			}
-		});
 	}
 	/** @type {import('vite').Plugin[]} */
 	const pluginsWithPreprocessors = config.plugins.filter((p) => p?.api?.sveltePreprocess);
diff --git a/packages/vite-plugin-svelte/src/utils/vite-plugin-svelte-cache.js b/packages/vite-plugin-svelte/src/utils/vite-plugin-svelte-cache.js
index 0f5538d3c..1a6580c31 100644
--- a/packages/vite-plugin-svelte/src/utils/vite-plugin-svelte-cache.js
+++ b/packages/vite-plugin-svelte/src/utils/vite-plugin-svelte-cache.js
@@ -1,17 +1,3 @@
-import { readFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { findClosestPkgJsonPath } from 'vitefu';
-import { normalizePath } from 'vite';
-
-/**
- * @typedef {{
- * 	name: string;
- * 	version: string;
- * 	svelte?: string;
- * 	path: string;
- * }} PackageInfo
- */
-
 /**
  * @class
  */
@@ -26,8 +12,6 @@ export class VitePluginSvelteCache {
 	#dependants = new Map();
 	/** @type {Map<string, any>} */
 	#errors = new Map();
-	/** @type {PackageInfo[]} */
-	#packageInfos = [];
 
 	/**
 	 * @param {import('../types/compile.d.ts').CompileData} compileData
@@ -149,6 +133,7 @@ export class VitePluginSvelteCache {
 			return this.#js.get(svelteRequest.normalizedFilename);
 		}
 	}
+
 	/**
 	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
 	 * @returns {any}
@@ -165,48 +150,4 @@ export class VitePluginSvelteCache {
 		const dependants = this.#dependants.get(path);
 		return dependants ? [...dependants] : [];
 	}
-
-	/**
-	 * @param {string} file
-	 * @returns {Promise<PackageInfo>}
-	 */
-	async getPackageInfo(file) {
-		let info = this.#packageInfos.find((pi) => file.startsWith(pi.path));
-		if (!info) {
-			info = await findPackageInfo(file);
-			this.#packageInfos.push(info);
-		}
-		return info;
-	}
-}
-
-/**
- * utility to get some info from the closest package.json with a "name" set
- *
- * @param {string} file to find info for
- * @returns {Promise<PackageInfo>}
- */
-async function findPackageInfo(file) {
-	/** @type {PackageInfo} */
-	const info = {
-		name: '$unknown',
-		version: '0.0.0-unknown',
-		path: '$unknown'
-	};
-	let path = await findClosestPkgJsonPath(file, (pkgPath) => {
-		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-		if (pkg.name != null) {
-			info.name = pkg.name;
-			if (pkg.version != null) {
-				info.version = pkg.version;
-			}
-			info.svelte = pkg.svelte;
-			return true;
-		}
-		return false;
-	});
-	// return normalized path with appended '/' so .startsWith works for future file checks
-	path = normalizePath(dirname(path ?? file)) + '/';
-	info.path = path;
-	return info;
 }
diff --git a/packages/vite-plugin-svelte/src/utils/vite-plugin-svelte-stats.js b/packages/vite-plugin-svelte/src/utils/vite-plugin-svelte-stats.js
index 6d8bcea42..4b7e825fd 100644
--- a/packages/vite-plugin-svelte/src/utils/vite-plugin-svelte-stats.js
+++ b/packages/vite-plugin-svelte/src/utils/vite-plugin-svelte-stats.js
@@ -1,6 +1,9 @@
 import { log } from './log.js';
 import { performance } from 'node:perf_hooks';
 import { normalizePath } from 'vite';
+import { findClosestPkgJsonPath } from 'vitefu';
+import { readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 
 /** @type {import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions} */
 const defaultCollectionOptions = {
@@ -63,19 +66,12 @@ function formatPackageStats(pkgStats) {
  * @class
  */
 export class VitePluginSvelteStats {
-	// package directory -> package name
-	/** @type {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} */
-	#cache;
+	/** @type {PackageInfo[]} */
+	#packageInfos = [];
+
 	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection[]} */
 	#collections = [];
 
-	/**
-	 * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
-	 */
-	constructor(cache) {
-		this.#cache = cache;
-	}
-
 	/**
 	 * @param {string} name
 	 * @param {Partial<import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions>} [opts]
@@ -173,7 +169,7 @@ export class VitePluginSvelteStats {
 	async #aggregateStatsResult(collection) {
 		const stats = collection.stats;
 		for (const stat of stats) {
-			stat.pkg = (await this.#cache.getPackageInfo(stat.file)).name;
+			stat.pkg = (await this.#getPackageInfo(stat.file)).name;
 		}
 
 		// group stats
@@ -197,4 +193,56 @@ export class VitePluginSvelteStats {
 		groups.sort((a, b) => b.duration - a.duration);
 		collection.packageStats = groups;
 	}
+	/**
+	 * @param {string} file
+	 * @returns {Promise<PackageInfo>}
+	 */
+	async #getPackageInfo(file) {
+		let info = this.#packageInfos.find((pi) => file.startsWith(pi.path));
+		if (!info) {
+			info = await findPackageInfo(file);
+			this.#packageInfos.push(info);
+		}
+		return info;
+	}
+}
+
+/**
+ * @typedef {{
+ * 	name: string;
+ * 	version: string;
+ * 	svelte?: string;
+ * 	path: string;
+ * }} PackageInfo
+ */
+
+/**
+ * utility to get some info from the closest package.json with a "name" set
+ *
+ * @param {string} file to find info for
+ * @returns {Promise<PackageInfo>}
+ */
+async function findPackageInfo(file) {
+	/** @type {PackageInfo} */
+	const info = {
+		name: '$unknown',
+		version: '0.0.0-unknown',
+		path: '$unknown'
+	};
+	let path = await findClosestPkgJsonPath(file, (pkgPath) => {
+		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+		if (pkg.name != null) {
+			info.name = pkg.name;
+			if (pkg.version != null) {
+				info.version = pkg.version;
+			}
+			info.svelte = pkg.svelte;
+			return true;
+		}
+		return false;
+	});
+	// return normalized path with appended '/' so .startsWith works for future file checks
+	path = normalizePath(dirname(path ?? file)) + '/';
+	info.path = path;
+	return info;
 }
diff --git a/packages/vite-plugin-svelte/src/utils/watch.js b/packages/vite-plugin-svelte/src/utils/watch.js
index de711cf16..5ed90bc29 100644
--- a/packages/vite-plugin-svelte/src/utils/watch.js
+++ b/packages/vite-plugin-svelte/src/utils/watch.js
@@ -6,10 +6,9 @@ import path from 'node:path';
 /**
  * @param {import('../types/options.d.ts').ResolvedOptions} options
  * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
- * @param {import('../types/id.d.ts').IdParser} requestParser
  * @returns {void}
  */
-export function setupWatchers(options, cache, requestParser) {
+export function setupWatchers(options, cache) {
 	const { server, configFile: svelteConfigFile } = options;
 	if (!server) {
 		return;
@@ -30,16 +29,7 @@ export function setupWatchers(options, cache, requestParser) {
 			}
 		});
 	};
-	/** @type {(filename: string) => void} */
-	const removeUnlinkedFromCache = (filename) => {
-		const svelteRequest = requestParser(filename, false);
-		if (svelteRequest) {
-			const removedFromCache = cache.remove(svelteRequest);
-			if (removedFromCache) {
-				log.debug(`cleared VitePluginSvelteCache for deleted file ${filename}`, undefined, 'hmr');
-			}
-		}
-	};
+
 	/** @type {(filename: string) => void} */
 	const triggerViteRestart = (filename) => {
 		if (serverConfig.middlewareMode) {
@@ -63,7 +53,7 @@ export function setupWatchers(options, cache, requestParser) {
 	const listenerCollection = {
 		add: [],
 		change: [emitChangeEventOnDependants],
-		unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
+		unlink: [emitChangeEventOnDependants]
 	};
 
 	if (svelteConfigFile !== false) {
diff --git a/packages/vite-plugin-svelte/types/index.d.ts b/packages/vite-plugin-svelte/types/index.d.ts
index aa741b9dd..d19e12fc7 100644
--- a/packages/vite-plugin-svelte/types/index.d.ts
+++ b/packages/vite-plugin-svelte/types/index.d.ts
@@ -206,6 +206,11 @@ declare module '@sveltejs/vite-plugin-svelte' {
 		 */
 		style?: boolean | InlineConfig | ResolvedConfig;
 	}
+	/**
+	 * returns a list of plugins to handle svelte files
+	 * plugins are named `vite-plugin-svelte:<task>`
+	 *
+	 * */
 	export function svelte(inlineOptions?: Partial<Options>): import("vite").Plugin[];
 	export function vitePreprocess(opts?: VitePreprocessOptions): import("svelte/compiler").PreprocessorGroup;
 	export function loadSvelteConfig(viteConfig?: import("vite").UserConfig, inlineOptions?: Partial<Options>): Promise<Partial<SvelteConfig> | undefined>;
diff --git a/packages/vite-plugin-svelte/types/index.d.ts.map b/packages/vite-plugin-svelte/types/index.d.ts.map
index 151f15172..72181787a 100644
--- a/packages/vite-plugin-svelte/types/index.d.ts.map
+++ b/packages/vite-plugin-svelte/types/index.d.ts.map
@@ -26,6 +26,6 @@
 		null,
 		null
 	],
-	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;iBC/JtBC,MAAMA;iBCXNC,cAAcA;iBCFRC,gBAAgBA",
+	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;;;;;;iBChLtBC,MAAMA;iBCMNC,cAAcA;iBCFRC,gBAAgBA",
 	"ignoreList": []
 }
\ No newline at end of file
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index d1a89c152..de7182ad6 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -506,6 +506,9 @@ importers:
       '@tsconfig/svelte':
         specifier: ^5.0.4
         version: 5.0.4
+      magic-string:
+        specifier: ^0.30.17
+        version: 0.30.17
       sass:
         specifier: ^1.89.2
         version: 1.89.2