@sveltejs/vite-plugin-svelte 7.0.0-next.1 → 7.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/vite-plugin-svelte",
-  "version": "7.0.0-next.1",
+  "version": "7.1.0",
   "license": "MIT",
   "files": [
     "src",
@@ -46,7 +46,7 @@
     "@types/debug": "^4.1.12",
     "sass": "^1.94.2",
     "svelte": "^5.45.4",
-    "vite": "^8.0.0-beta.7"
+    "vite": "^8.0.9"
   },
   "scripts": {
     "check:publint": "publint --strict",

package/src/index.js

@@ -1,3 +1,7 @@
+/** @import { Options } from './public.js' */
+/** @import { PluginAPI } from './types/plugin-api.js' */
+/** @import { Plugin } from 'vite' */
+
 import process from 'node:process';
 import { log } from './utils/log.js';
 import { configure } from './plugins/configure.js';
@@ -14,14 +18,14 @@ 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[]}
+ * @param {Partial<Options>} [inlineOptions]
+ * @returns {Plugin[]}
  */
 export function svelte(inlineOptions) {
 	if (process.env.DEBUG != null) {
 		log.setLevel('debug');
 	}
-	/** @type {import('./types/plugin-api.js').PluginAPI} */
+	/** @type {PluginAPI} */
 	// @ts-expect-error initialize empty to guard against early use
 	const api = {}; // initialized by configure plugin, used in others
 	return [

package/src/plugins/compile-module.js

@@ -1,3 +1,9 @@
+/** @import { ModuleIdParser } from '../types/id.js' */
+/** @import { ResolvedOptions } from '../types/options.js' */
+/** @import { PluginAPI } from '../types/plugin-api.js' */
+/** @import { CompileOptions, ModuleCompileOptions } from 'svelte/compiler' */
+/** @import { Plugin } from 'vite' */
+
 import { buildModuleIdFilter, buildModuleIdParser } from '../utils/id.js';
 import * as svelteCompiler from 'svelte/compiler';
 import { log, logCompilerWarnings } from '../utils/log.js';
@@ -5,25 +11,25 @@ import { toRollupError } from '../utils/error.js';
 import { isSvelteWithAsync } from '../utils/svelte-version.js';
 
 /**
- * @param {import('../types/plugin-api.d.ts').PluginAPI} api
- * @returns {import('vite').Plugin}
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function compileModule(api) {
 	/**
-	 * @type {import("../types/options.js").ResolvedOptions}
+	 * @type {ResolvedOptions}
 	 */
 	let options;
 	/**
-	 * @type {import("../types/id.js").ModuleIdParser}
+	 * @type {ModuleIdParser}
 	 */
 	let idParser;
 
 	/**
-	 * @type {import('svelte/compiler').ModuleCompileOptions}
+	 * @type {ModuleCompileOptions}
 	 */
 	let staticModuleCompileOptions;
 
-	/** @type {import('vite').Plugin} */
+	/** @type {Plugin} */
 	const plugin = {
 		name: 'vite-plugin-svelte:compile-module',
 		enforce: 'post',
@@ -42,7 +48,7 @@ export function compileModule(api) {
 					return;
 				}
 				const filename = moduleRequest.filename;
-				/** @type {import('svelte/compiler').CompileOptions} */
+				/** @type {CompileOptions} */
 				const compileOptions = {
 					...staticModuleCompileOptions,
 					dev: !this.environment.config.isProduction,
@@ -96,11 +102,11 @@ export function compileModule(api) {
 
 /**
  *
- * @param {import('svelte/compiler').CompileOptions} compilerOptions
- * @return {import('svelte/compiler').ModuleCompileOptions}
+ * @param {CompileOptions} compilerOptions
+ * @return {ModuleCompileOptions}
  */
 function filterNonModuleCompilerOptions(compilerOptions) {
-	/** @type {Array<keyof import('svelte/compiler').ModuleCompileOptions>} */
+	/** @type {Array<keyof ModuleCompileOptions>} */
 	const knownModuleCompileOptionNames = ['dev', 'generate', 'filename', 'rootDir', 'warningFilter'];
 	if (isSvelteWithAsync) {
 		knownModuleCompileOptionNames.push('experimental');
@@ -108,7 +114,7 @@ function filterNonModuleCompilerOptions(compilerOptions) {
 	// not typed but this is temporary until svelte itself ignores CompileOptions passed to compileModule
 	const experimentalModuleCompilerOptionNames = ['async'];
 
-	/** @type {import('svelte/compiler').ModuleCompileOptions} */
+	/** @type {ModuleCompileOptions} */
 	const filtered = filterByPropNames(compilerOptions, knownModuleCompileOptionNames);
 	if (filtered.experimental) {
 		filtered.experimental = filterByPropNames(

package/src/plugins/compile.js

@@ -1,21 +1,26 @@
+/** @import { CompileSvelte } from '../types/compile.js' */
+/** @import { ResolvedOptions } from '../types/options.js' */
+/** @import { PluginAPI } from '../types/plugin-api.js' */
+/** @import { Plugin } from 'vite' */
+
 import { toRollupError } from '../utils/error.js';
 import { logCompilerWarnings } from '../utils/log.js';
 
 /**
- * @param {import('../types/plugin-api.d.ts').PluginAPI} api
- * @returns {import('vite').Plugin}
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function compile(api) {
 	/**
-	 * @type {import("../types/options.js").ResolvedOptions}
+	 * @type {ResolvedOptions}
 	 */
 	let options;
 
 	/**
-	 * @type {import("../types/compile.d.ts").CompileSvelte}
+	 * @type {CompileSvelte}
 	 */
 	let compileSvelte;
-	/** @type {import('vite').Plugin} */
+	/** @type {Plugin} */
 	const plugin = {
 		name: 'vite-plugin-svelte:compile',
 		configResolved() {

package/src/plugins/configure.js

@@ -1,3 +1,8 @@
+/** @import { Options } from '../public.js' */
+/** @import { PreResolvedOptions } from '../types/options.js' */
+/** @import { PluginAPI } from '../types/plugin-api.js' */
+/** @import { Plugin } from 'vite' */
+
 import process from 'node:process';
 import { isDebugNamespaceEnabled, log } from '../utils/log.js';
 import { VitePluginSvelteStats } from '../utils/vite-plugin-svelte-stats.js';
@@ -13,19 +18,19 @@ import { buildIdFilter, buildIdParser } from '../utils/id.js';
 import { createCompileSvelte } from '../utils/compile.js';
 
 /**
- * @param {Partial<import('../public.d.ts').Options>} [inlineOptions]
- * @param {import('../types/plugin-api.d.ts').PluginAPI} api
- * @returns {import('vite').Plugin}
+ * @param {Partial<Options>} [inlineOptions]
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function configure(api, inlineOptions) {
 	validateInlineOptions(inlineOptions);
 
 	/**
-	 * @type {import("../types/options.d.ts").PreResolvedOptions}
+	 * @type {PreResolvedOptions}
 	 */
 	let preOptions;
 
-	/** @type {import('vite').Plugin} */
+	/** @type {Plugin} */
 	return {
 		name: 'vite-plugin-svelte:config',
 		api,

package/src/plugins/hot-update.js

@@ -1,18 +1,23 @@
+/** @import { IdParser } from '../types/id.js' */
+/** @import { ResolvedOptions } from '../types/options.js' */
+/** @import { PluginAPI } from '../types/plugin-api.js' */
+/** @import { Plugin } from 'vite' */
+
 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}
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function hotUpdate(api) {
 	/**
-	 * @type {import("../types/options.js").ResolvedOptions}
+	 * @type {ResolvedOptions}
 	 */
 	let options;
 	/**
-	 * @type {import('../types/id.d.ts').IdParser}
+	 * @type {IdParser}
 	 */
 	let idParser;
 
@@ -22,7 +27,7 @@ export function hotUpdate(api) {
 	 */
 	const transformResultCache = new Map();
 
-	/** @type {import('vite').Plugin} */
+	/** @type {Plugin} */
 	const plugin = {
 		name: 'vite-plugin-svelte:hot-update',
 		enforce: 'post',

package/src/plugins/inspector/index.js

@@ -1,3 +1,7 @@
+/** @import { InspectorOptions } from '../../public.js' */
+/** @import { PluginAPI } from '../../types/plugin-api.js' */
+/** @import { Plugin } from 'vite' */
+
 import { normalizePath } from 'vite';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -22,14 +26,14 @@ function getInspectorPath() {
 }
 
 /**
- * @param {import('../../types/plugin-api.d.ts').PluginAPI} api
- * @returns {import('vite').Plugin}
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function svelteInspector(api) {
 	const inspectorPath = getInspectorPath();
 	log.debug(`svelte inspector path: ${inspectorPath}`, null, 'inspector');
 
-	/** @type {import('../../public.d.ts').InspectorOptions} */
+	/** @type {InspectorOptions} */
 	let inspectorOptions;
 	let disabled = false;
 

package/src/plugins/inspector/options.js

@@ -1,8 +1,11 @@
+/** @import { InspectorOptions } from '../../public.js' */
+/** @import { ResolvedConfig } from 'vite' */
+
 import process from 'node:process';
 import { loadEnv } from 'vite';
 import { log } from '../../utils/log.js';
 
-/** @type {import('../../public.d.ts').InspectorOptions} */
+/** @type {InspectorOptions} */
 export const defaultInspectorOptions = {
 	toggleKeyCombo: 'alt-x',
 	navKeys: { parent: 'ArrowUp', child: 'ArrowDown', next: 'ArrowRight', prev: 'ArrowLeft' },
@@ -15,8 +18,8 @@ export const defaultInspectorOptions = {
 };
 
 /**
- * @param {import('vite').ResolvedConfig} config
- * @returns {Partial<import('../../public.d.ts').InspectorOptions> | boolean | void}
+ * @param {ResolvedConfig} config
+ * @returns {Partial<InspectorOptions> | boolean | void}
  */
 export function parseEnvironmentOptions(config) {
 	const env = loadEnv(config.mode, config.envDir ?? process.cwd(), 'SVELTE_INSPECTOR');

package/src/plugins/load-compiled-css.js

@@ -1,11 +1,14 @@
+/** @import { PluginAPI } from '../types/plugin-api.js' */
+/** @import { Plugin } from 'vite' */
+
 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}
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function loadCompiledCss(api) {
 	let useLocalCache = false;

package/src/plugins/load-custom.js

@@ -1,3 +1,6 @@
+/** @import { PluginAPI } from '../types/plugin-api.js' */
+/** @import { Plugin } from 'vite' */
+
 import fs from 'node:fs';
 import { log } from '../utils/log.js';
 
@@ -5,11 +8,11 @@ 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}
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function loadCustom(api) {
-	/** @type {import('vite').Plugin} */
+	/** @type {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

package/src/plugins/preprocess.js

@@ -1,3 +1,10 @@
+/** @import { PreprocessSvelte } from '../types/compile.js' */
+/** @import { SvelteRequest } from '../types/id.js' */
+/** @import { ResolvedOptions } from '../types/options.js' */
+/** @import { PluginAPI } from '../types/plugin-api.js' */
+/** @import { PreprocessorGroup } from 'svelte/compiler' */
+/** @import { Plugin, ResolvedConfig, Rollup, ViteDevServer } from 'vite' */
+
 import { toRollupError } from '../utils/error.js';
 import { mapToRelative } from '../utils/sourcemaps.js';
 import * as svelte from 'svelte/compiler';
@@ -7,12 +14,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 /**
- * @param {import('../types/plugin-api.d.ts').PluginAPI} api
- * @returns {import('vite').Plugin}
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function preprocess(api) {
 	/**
-	 * @type {import("../types/options.js").ResolvedOptions}
+	 * @type {ResolvedOptions}
 	 */
 	let options;
 
@@ -22,11 +29,11 @@ export function preprocess(api) {
 	let dependenciesCache;
 
 	/**
-	 * @type {import("../types/compile.d.ts").PreprocessSvelte}
+	 * @type {PreprocessSvelte}
 	 */
 	let preprocessSvelte;
 
-	/** @type {import('vite').Plugin} */
+	/** @type {Plugin} */
 	const plugin = {
 		name: 'vite-plugin-svelte:preprocess',
 		enforce: 'pre',
@@ -73,7 +80,7 @@ export function preprocess(api) {
 						}
 					}
 
-					/** @type {import('vite').Rollup.SourceDescription}*/
+					/** @type {Rollup.SourceDescription}*/
 					const result = { code: preprocessed.code };
 					if (preprocessed.map) {
 						// @ts-expect-error type differs but should work
@@ -89,12 +96,12 @@ export function preprocess(api) {
 	return plugin;
 }
 /**
- * @param {import("../types/options.js").ResolvedOptions} options
- * @param {import("vite").ResolvedConfig} resolvedConfig
- * @returns {import('../types/compile.d.ts').PreprocessSvelte}
+ * @param {ResolvedOptions} options
+ * @param {ResolvedConfig} resolvedConfig
+ * @returns {PreprocessSvelte}
  */
 function createPreprocessSvelte(options, resolvedConfig) {
-	/** @type {Array<import('svelte/compiler').PreprocessorGroup>} */
+	/** @type {Array<PreprocessorGroup>} */
 	const preprocessors = arraify(options.preprocess);
 
 	for (const preprocessor of preprocessors) {
@@ -103,7 +110,7 @@ function createPreprocessSvelte(options, resolvedConfig) {
 		}
 	}
 
-	/** @type {import('../types/compile.d.ts').PreprocessSvelte} */
+	/** @type {PreprocessSvelte} */
 	return async function preprocessSvelte(svelteRequest, code) {
 		const { filename } = svelteRequest;
 		let preprocessed;
@@ -133,11 +140,11 @@ class DependenciesCache {
 	/** @type {Map<string, Set<string>>} */
 	#dependants = new Map();
 
-	/** @type {import('vite').ViteDevServer} */
+	/** @type {ViteDevServer} */
 	#server;
 	/**
 	 *
-	 * @param {import('vite').ViteDevServer} server
+	 * @param {ViteDevServer} server
 	 */
 	constructor(server) {
 		this.#server = server;
@@ -184,7 +191,7 @@ class DependenciesCache {
 
 	/**
 	 *
-	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
+	 * @param {SvelteRequest} svelteRequest
 	 * @param {string[]} dependencies
 	 */
 	update(svelteRequest, dependencies) {

package/src/plugins/setup-optimizer.js

@@ -1,57 +1,61 @@
+/** @import { Code } from '../types/compile.js' */
+/** @import { ResolvedOptions } from '../types/options.js' */
+/** @import { PluginAPI } from '../types/plugin-api.js' */
+/** @import { StatCollection } from '../types/vite-plugin-svelte-stats.js' */
+/** @import { CompileOptions } from 'svelte/compiler' */
+/** @import { Plugin, ResolvedConfig, Rolldown, UserConfig } from 'vite' */
+
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import * as svelte from 'svelte/compiler';
 import { log } from '../utils/log.js';
 import { toRollupError } from '../utils/error.js';
+import { SVELTE_IMPORTS } from '../utils/constants.js';
+import { isDepExcluded } from 'vitefu';
 
 /**
- * @typedef {NonNullable<import('vite').Rollup.Plugin>} RollupPlugin
+ * @typedef {NonNullable<Rolldown.Plugin>} RollupPlugin
  */
 
 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}
+ * @param {PluginAPI} api
+ * @returns {Plugin}
  */
 export function setupOptimizer(api) {
-	/** @type {import('vite').ResolvedConfig} */
+	/** @type {ResolvedConfig} */
 	let viteConfig;
 
 	return {
 		name: 'vite-plugin-svelte:setup-optimizer',
 		apply: 'serve',
-		config() {
-			/** @type {import('vite').UserConfig['optimizeDeps']} */
+		configEnvironment(name, config) {
+			// fall back to vite behavior when consumer isn't set
+			const consumer = (config.consumer ?? name === 'client') ? 'client' : 'server';
+			/** @type {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
 
+			// Add optimizer plugins to prebundle Svelte files.
 			optimizeDeps.rolldownOptions = {
 				plugins: [
-					placeholderRolldownOptimizerPlugin(optimizeSveltePluginName),
-					placeholderRolldownOptimizerPlugin(optimizeSvelteModulePluginName)
+					rolldownOptimizerPlugin(api, consumer, true),
+					rolldownOptimizerPlugin(api, consumer, false)
 				]
 			};
 
+			if (consumer === 'server' && !isDepExcluded('svelte', config.optimizeDeps?.exclude ?? [])) {
+				optimizeDeps.include = [...SVELTE_IMPORTS];
+			}
+
 			return { optimizeDeps };
 		},
 		configResolved(c) {
 			viteConfig = c;
-			const optimizeDeps = c.optimizeDeps;
-			const plugins =
-				// @ts-expect-error not typed
-				optimizeDeps.rolldownOptions?.plugins?.filter((p) =>
-					[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
-				) ?? [];
-			for (const plugin of plugins) {
-				patchRolldownOptimizerPlugin(plugin, api.options);
-			}
 		},
 		async buildStart() {
 			if (!api.options.prebundleSvelteLibraries) return;
@@ -66,21 +70,29 @@ export function setupOptimizer(api) {
 }
 
 /**
- * @param {RollupPlugin} plugin
- * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {import('../types/plugin-api.d.ts').PluginAPI} api
+ * @param {'server'|'client'} consumer
+ * @param {boolean} components
+ * @return {Rolldown.Plugin}
  */
-function patchRolldownOptimizerPlugin(plugin, options) {
-	const components = plugin.name === optimizeSveltePluginName;
+function rolldownOptimizerPlugin(api, consumer, components) {
+	const name = components ? optimizeSveltePluginName : optimizeSvelteModulePluginName;
 	const compileFn = components ? compileSvelte : compileSvelteModule;
 	const statsName = components ? 'prebundle library components' : 'prebundle library modules';
 	const includeRe = components ? /^[^?#]+\.svelte(?:[?#]|$)/ : /^[^?#]+\.svelte\.[jt]s(?:[?#]|$)/;
-	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
+	const generate = consumer === 'server' ? 'server' : 'client';
+	/** @type {StatCollection | undefined} */
 	let statsCollection;
 
+	/**@type {Rolldown.Plugin}*/
+	const plugin = {
+		name
+	};
+
 	plugin.options = (opts) => {
 		// @ts-expect-error plugins is an array here
 		const isScanner = opts.plugins.some(
-			(/** @type {{ name: string; }} */ p) => p.name === 'vite:dep-scan:resolve'
+			(/** @type {{ name: string; } | undefined} */ p) => p?.name === 'vite:dep-scan:resolve'
 		);
 		if (isScanner) {
 			delete plugin.buildStart;
@@ -95,14 +107,14 @@ function patchRolldownOptimizerPlugin(plugin, options) {
 				 */
 				async handler(code, filename) {
 					try {
-						return await compileFn(options, { filename, code }, statsCollection);
+						return await compileFn(api.options, { filename, code }, generate, statsCollection);
 					} catch (e) {
-						throw toRollupError(e, options);
+						throw toRollupError(e, api.options);
 					}
 				}
 			};
 			plugin.buildStart = () => {
-				statsCollection = options.stats?.startCollection(statsName, {
+				statsCollection = api.options.stats?.startCollection(statsName, {
 					logResult: (c) => c.stats.length > 1
 				});
 			};
@@ -111,27 +123,30 @@ function patchRolldownOptimizerPlugin(plugin, options) {
 			};
 		}
 	};
+
+	return plugin;
 }
 
 /**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {ResolvedOptions} options
  * @param {{ filename: string, code: string }} input
- * @param {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} [statsCollection]
- * @returns {Promise<import('../types/compile.d.ts').Code>}
+ * @param {'client'|'server'} generate
+ * @param {StatCollection} [statsCollection]
+ * @returns {Promise<Code>}
  */
-async function compileSvelte(options, { filename, code }, statsCollection) {
+async function compileSvelte(options, { filename, code }, generate, statsCollection) {
 	let css = options.compilerOptions.css;
 	if (css !== 'injected') {
 		// TODO ideally we'd be able to externalize prebundled styles too, but for now always put them in the js
 		css = 'injected';
 	}
-	/** @type {import('svelte/compiler').CompileOptions} */
+	/** @type {CompileOptions} */
 	const compileOptions = {
 		dev: true, // default to dev: true because prebundling is only used in dev
 		...options.compilerOptions,
 		css,
 		filename,
-		generate: 'client'
+		generate
 	};
 
 	let preprocessed;
@@ -180,17 +195,18 @@ async function compileSvelte(options, { filename, code }, statsCollection) {
 }
 
 /**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {ResolvedOptions} options
  * @param {{ filename: string; code: string }} input
- * @param {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} [statsCollection]
- * @returns {Promise<import('../types/compile.d.ts').Code>}
+ * @param {'client'|'server'} generate
+ * @param {StatCollection} [statsCollection]
+ * @returns {Promise<Code>}
  */
-async function compileSvelteModule(options, { filename, code }, statsCollection) {
+async function compileSvelteModule(options, { filename, code }, generate, statsCollection) {
 	const endStat = statsCollection?.start(filename);
 	const compiled = svelte.compileModule(code, {
 		dev: options.compilerOptions?.dev ?? true, // default to dev: true because prebundling is only used in dev
 		filename,
-		generate: 'client'
+		generate
 	});
 	if (endStat) {
 		endStat();
@@ -202,7 +218,7 @@ async function compileSvelteModule(options, { filename, code }, statsCollection)
 }
 
 // List of options that changes the prebundling result
-/** @type {(keyof import('../types/options.d.ts').ResolvedOptions)[]} */
+/** @type {(keyof ResolvedOptions)[]} */
 const PREBUNDLE_SENSITIVE_OPTIONS = [
 	'compilerOptions',
 	'configFile',
@@ -215,7 +231,7 @@ const PREBUNDLE_SENSITIVE_OPTIONS = [
  * stores svelte metadata in cache dir and compares if it has changed
  *
  * @param {string} cacheDir
- * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {ResolvedOptions} options
  * @returns {Promise<boolean>} Whether the Svelte metadata has changed
  */
 async function svelteMetadataChanged(cacheDir, options) {
@@ -241,23 +257,8 @@ async function svelteMetadataChanged(cacheDir, options) {
 }
 
 /**
- *
- * @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>}
+ * @param {ResolvedOptions} options
+ * @returns {Partial<ResolvedOptions>}
  */
 function generateSvelteMetadata(options) {
 	/** @type {Record<string, any>} */