@sveltejs/kit 1.0.0-next.470 → 1.0.0-next.473

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.470",
+  "version": "1.0.0-next.473",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/src/core/config/options.js

@@ -171,20 +171,10 @@ const options = object(
 
 			inlineStyleThreshold: number(0),
 
-			methodOverride: object({
-				parameter: string('_method'),
-				allowed: validate([], (input, keypath) => {
-					if (!Array.isArray(input) || !input.every((method) => typeof method === 'string')) {
-						throw new Error(`${keypath} must be an array of strings`);
-					}
-
-					if (input.map((i) => i.toUpperCase()).includes('GET')) {
-						throw new Error(`${keypath} cannot contain "GET"`);
-					}
-
-					return input;
-				})
-			}),
+			methodOverride: error(
+				() =>
+					'Method overrides have been removed in favor of actions. See the PR for more information: https://github.com/sveltejs/kit/pull/6469'
+			),
 
 			moduleExtensions: string_array(['.js', '.ts']),
 

package/src/core/prerender/prerender.js

@@ -237,10 +237,11 @@ export async function prerender() {
 			const encoded_dependency_path = new URL(dependency_path, 'http://localhost').pathname;
 			const decoded_dependency_path = decodeURI(encoded_dependency_path);
 
-			const prerender = result.response.headers.get('x-sveltekit-prerender');
+			const headers = Object.fromEntries(result.response.headers);
 
+			const prerender = headers['x-sveltekit-prerender'];
 			if (prerender) {
-				const route_id = /** @type {string} */ (result.response.headers.get('x-sveltekit-routeid'));
+				const route_id = headers['x-sveltekit-routeid'];
 				const existing_value = prerender_map.get(route_id);
 				if (existing_value !== 'auto') {
 					prerender_map.set(route_id, prerender === 'true' ? true : 'auto');
@@ -259,7 +260,10 @@ export async function prerender() {
 			);
 		}
 
-		if (config.prerender.crawl && response.headers.get('content-type') === 'text/html') {
+		// avoid triggering `filterSerializeResponseHeaders` guard
+		const headers = Object.fromEntries(response.headers);
+
+		if (config.prerender.crawl && headers['content-type'] === 'text/html') {
 			for (const href of crawl(body.toString())) {
 				if (href.startsWith('data:') || href.startsWith('#')) continue;
 
@@ -288,7 +292,9 @@ export async function prerender() {
 	 */
 	function save(category, response, body, decoded, encoded, referrer, referenceType) {
 		const response_type = Math.floor(response.status / 100);
-		const type = /** @type {string} */ (response.headers.get('content-type'));
+		const headers = Object.fromEntries(response.headers);
+
+		const type = headers['content-type'];
 		const is_html = response_type === REDIRECT || type === 'text/html';
 
 		const file = output_filename(decoded, is_html);
@@ -297,7 +303,7 @@ export async function prerender() {
 		if (written.has(file)) return;
 
 		if (response_type === REDIRECT) {
-			const location = response.headers.get('location');
+			const location = headers['location'];
 
 			if (location) {
 				const resolved = resolve(encoded, location);
@@ -305,7 +311,7 @@ export async function prerender() {
 					enqueue(decoded, decodeURI(resolved), resolved);
 				}
 
-				if (!response.headers.get('x-sveltekit-normalize')) {
+				if (!headers['x-sveltekit-normalize']) {
 					mkdirp(dirname(dest));
 
 					log.warn(`${response.status} ${decoded} -> ${location}`);

package/src/core/sync/write_root.js

@@ -21,16 +21,16 @@ export function write_root(manifest_data, output) {
 
 	let l = max_depth;
 
-	let pyramid = `<svelte:component this={components[${l}]} data={data_${l}} {errors}/>`;
+	let pyramid = `<svelte:component this={components[${l}]} data={data_${l}} {form} />`;
 
 	while (l--) {
 		pyramid = `
 			{#if components[${l + 1}]}
-				<svelte:component this={components[${l}]} data={data_${l}} {errors}>
+				<svelte:component this={components[${l}]} data={data_${l}}>
 					${pyramid.replace(/\n/g, '\n\t\t\t\t\t')}
 				</svelte:component>
 			{:else}
-				<svelte:component this={components[${l}]} data={data_${l}} {errors} />
+				<svelte:component this={components[${l}]} data={data_${l}} {form} />
 			{/if}
 		`
 			.replace(/^\t\t\t/gm, '')
@@ -50,8 +50,8 @@ export function write_root(manifest_data, output) {
 				export let page;
 
 				export let components;
+				export let form;
 				${levels.map((l) => `export let data_${l} = null;`).join('\n\t\t\t\t')}
-				export let errors;
 
 				if (!browser) {
 					setContext('__svelte__', stores);

package/src/core/sync/write_types/index.js

@@ -21,9 +21,6 @@ try {
 
 const cwd = process.cwd();
 
-const shared_names = new Set(['load']);
-const server_names = new Set(['load', 'POST', 'PUT', 'PATCH', 'DELETE']); // TODO replace with a single `action`
-
 /**
  * Creates types for the whole manifest
  * @param {import('types').ValidatedConfig} config
@@ -193,6 +190,7 @@ function update_types(config, routes, route) {
 
 		if (route.leaf.server) {
 			exports.push(`export type Action = Kit.Action<RouteParams>`);
+			exports.push(`export type Actions = Kit.Actions<RouteParams>`);
 		}
 	}
 
@@ -231,6 +229,9 @@ function update_types(config, routes, route) {
 
 	if (route.endpoint) {
 		exports.push(`export type RequestHandler = Kit.RequestHandler<RouteParams>;`);
+	}
+
+	if (route.leaf?.server || route.endpoint) {
 		exports.push(`export type RequestEvent = Kit.RequestEvent<RouteParams>;`);
 	}
 
@@ -270,7 +271,7 @@ function process_node(node, outdir, is_page, all_pages_have_load = true) {
 
 	if (node.server) {
 		const content = fs.readFileSync(node.server, 'utf8');
-		const proxy = tweak_types(content, server_names);
+		const proxy = tweak_types(content, true);
 		const basename = path.basename(node.server);
 		if (proxy?.modified) {
 			fs.writeFileSync(`${outdir}/proxy${basename}`, proxy.code);
@@ -295,23 +296,19 @@ function process_node(node, outdir, is_page, all_pages_have_load = true) {
 		exports.push(`export type ${prefix}ServerLoadEvent = Parameters<${prefix}ServerLoad>[0];`);
 
 		if (is_page) {
-			let errors = 'unknown';
+			let type = 'unknown';
 			if (proxy) {
-				const types = [];
-				for (const method of ['POST', 'PUT', 'PATCH', 'DELETE']) {
-					if (proxy.exports.includes(method)) {
-						// If the file wasn't tweaked, we can use the return type of the original file.
-						// The advantage is that type updates are reflected without saving.
-						const from = proxy.modified
-							? `./proxy${replace_ext_with_js(basename)}`
-							: path_to_original(outdir, node.server);
-
-						types.push(`Kit.AwaitedErrors<typeof import('${from}').${method}>`);
-					}
+				if (proxy.exports.includes('actions')) {
+					// If the file wasn't tweaked, we can use the return type of the original file.
+					// The advantage is that type updates are reflected without saving.
+					const from = proxy.modified
+						? `./proxy${replace_ext_with_js(basename)}`
+						: path_to_original(outdir, node.server);
+
+					type = `Kit.AwaitedActions<typeof import('${from}').actions>`;
 				}
-				errors = types.length ? types.join(' | ') : 'null';
 			}
-			exports.push(`export type Errors = ${errors};`);
+			exports.push(`export type ActionData = ${type};`);
 		}
 	} else {
 		server_data = 'null';
@@ -323,7 +320,7 @@ function process_node(node, outdir, is_page, all_pages_have_load = true) {
 
 	if (node.shared) {
 		const content = fs.readFileSync(node.shared, 'utf8');
-		const proxy = tweak_types(content, shared_names);
+		const proxy = tweak_types(content, false);
 		if (proxy?.modified) {
 			fs.writeFileSync(`${outdir}/proxy${path.basename(node.shared)}`, proxy.code);
 			written_proxies.push(`proxy${path.basename(node.shared)}`);
@@ -426,10 +423,12 @@ function replace_ext_with_js(file_path) {
 
 /**
  * @param {string} content
- * @param {Set<string>} names
+ * @param {boolean} is_server
  * @returns {Proxy}
  */
-export function tweak_types(content, names) {
+export function tweak_types(content, is_server) {
+	const names = new Set(is_server ? ['load', 'actions'] : ['load']);
+
 	try {
 		let modified = false;
 
@@ -480,6 +479,7 @@ export function tweak_types(content, names) {
 		 * @param {import('typescript').Node} value
 		 */
 		function replace_jsdoc_type_tags(node, value) {
+			let _modified = false;
 			// @ts-ignore
 			if (node.jsDoc) {
 				// @ts-ignore
@@ -492,22 +492,27 @@ export function tweak_types(content, names) {
 								ts.isArrowFunction(value);
 
 							if (is_fn && value.parameters?.length > 0) {
+								const name = ts.isIdentifier(value.parameters[0].name)
+									? value.parameters[0].name.text
+									: 'event';
 								code.overwrite(tag.tagName.pos, tag.tagName.end, 'param');
 								code.prependRight(tag.typeExpression.pos + 1, 'Parameters<');
 								code.appendLeft(tag.typeExpression.end - 1, '>[0]');
-								code.appendLeft(tag.typeExpression.end, ' event');
+								code.appendLeft(tag.typeExpression.end, ` ${name}`);
 							} else {
 								code.overwrite(tag.pos, tag.end, '');
 							}
-							modified = true;
+							_modified = true;
 						}
 					}
 				}
 			}
+			modified ||= _modified;
+			return _modified;
 		}
 
 		ast.forEachChild((node) => {
-			if (ts.isFunctionDeclaration(node) && node.name?.text && names.has(node.name?.text)) {
+			if (ts.isFunctionDeclaration(node) && node.name?.text && node.name?.text === 'load') {
 				// remove JSDoc comment above `export function load ...`
 				replace_jsdoc_type_tags(node, node);
 			}
@@ -525,7 +530,7 @@ export function tweak_types(content, names) {
 				for (const declaration of node.declarationList.declarations) {
 					if (
 						ts.isIdentifier(declaration.name) &&
-						names.has(declaration.name.text) &&
+						declaration.name.text === 'load' &&
 						declaration.initializer
 					) {
 						// edge case — remove JSDoc comment above individual export
@@ -548,7 +553,6 @@ export function tweak_types(content, names) {
 								rhs.parameters.length
 							) {
 								const arg = rhs.parameters[0];
-
 								const add_parens = content[arg.pos - 1] !== '(';
 
 								if (add_parens) code.prependRight(arg.pos, '(');
@@ -569,6 +573,80 @@ export function tweak_types(content, names) {
 
 							modified = true;
 						}
+					} else if (
+						is_server &&
+						ts.isIdentifier(declaration.name) &&
+						declaration.name?.text === 'actions' &&
+						declaration.initializer
+					) {
+						// remove JSDoc comment from `export const actions = ..`
+						const removed = replace_jsdoc_type_tags(node, declaration.initializer);
+						// ... and move type to each individual action
+						if (removed) {
+							const rhs = declaration.initializer;
+							if (ts.isObjectLiteralExpression(rhs)) {
+								for (const prop of rhs.properties) {
+									if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+										const rhs = prop.initializer;
+										const replaced = replace_jsdoc_type_tags(prop, rhs);
+										if (
+											!replaced &&
+											rhs &&
+											(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
+											rhs.parameters?.[0]
+										) {
+											const name = ts.isIdentifier(rhs.parameters[0].name)
+												? rhs.parameters[0].name.text
+												: 'event';
+											code.prependRight(
+												rhs.pos,
+												`/** @param {import('./$types').RequestEvent} ${name} */ `
+											);
+										}
+									}
+								}
+							}
+						}
+
+						// remove type from `export const actions: Actions ...`
+						if (declaration.type) {
+							let a = declaration.type.pos;
+							let b = declaration.type.end;
+							while (/\s/.test(content[a])) a += 1;
+
+							const type = content.slice(a, b);
+							code.remove(declaration.name.end, declaration.type.end);
+							code.append(`;null as any as ${type};`);
+							modified = true;
+
+							// ... and move type to each individual action
+							const rhs = declaration.initializer;
+							if (ts.isObjectLiteralExpression(rhs)) {
+								for (const prop of rhs.properties) {
+									if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+										const rhs = prop.initializer;
+
+										if (
+											rhs &&
+											(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
+											rhs.parameters.length
+										) {
+											const arg = rhs.parameters[0];
+											const add_parens = content[arg.pos - 1] !== '(';
+
+											if (add_parens) code.prependRight(arg.pos, '(');
+
+											if (arg && !arg.type) {
+												code.appendLeft(
+													arg.name.end,
+													`: import('./$types').RequestEvent` + (add_parens ? ')' : '')
+												);
+											}
+										}
+									}
+								}
+							}
+						}
 					}
 				}
 			}

package/src/exports/index.js

@@ -1,4 +1,4 @@
-import { HttpError, Redirect } from '../runtime/control.js';
+import { HttpError, Redirect, ValidationError } from '../runtime/control.js';
 
 /**
  * Creates an `HttpError` object with an HTTP status code and an optional message.
@@ -43,3 +43,12 @@ export function json(data, init) {
 		headers
 	});
 }
+
+/**
+ * Generates a `ValidationError` object.
+ * @param {number} status
+ * @param {Record<string, any> | undefined} [data]
+ */
+export function invalid(status, data) {
+	return new ValidationError(status, data);
+}

package/src/exports/node/polyfills.js

@@ -1,7 +1,7 @@
 import { fetch, Response, Request, Headers } from 'undici';
 import { ReadableStream, TransformStream, WritableStream } from 'stream/web';
 import { Readable } from 'stream';
-import { Request as NodeFetchRequest } from 'node-fetch';
+import { Request as NodeFetchRequest, FormData } from 'node-fetch';
 import { webcrypto as crypto } from 'crypto';
 
 /** @type {Record<string, any>} */
@@ -24,7 +24,8 @@ const globals = {
 	Headers,
 	ReadableStream,
 	TransformStream,
-	WritableStream
+	WritableStream,
+	FormData
 };
 
 // exported for dev/preview and node environments

package/src/exports/vite/build/build_server.js

@@ -74,7 +74,6 @@ export class Server {
 			},
 			hooks: null,
 			manifest,
-			method_override: ${s(config.kit.methodOverride)},
 			paths: { base, assets },
 			public_env: {},
 			read,

package/src/exports/vite/dev/index.js

@@ -13,6 +13,7 @@ import * as sync from '../../../core/sync/sync.js';
 import { get_mime_lookup, runtime_base, runtime_prefix } from '../../../core/utils.js';
 import { prevent_illegal_vite_imports, resolve_entry } from '../utils.js';
 import { compact } from '../../../utils/array.js';
+import { normalizePath } from 'vite';
 
 // Vite doesn't expose this so we just copy the list for now
 // https://github.com/vitejs/vite/blob/3edd1af56e980aef56641a5a51cf2932bb580d41/packages/vite/src/node/plugins/css.ts#L96
@@ -24,10 +25,9 @@ const cwd = process.cwd();
  * @param {import('vite').ViteDevServer} vite
  * @param {import('vite').ResolvedConfig} vite_config
  * @param {import('types').ValidatedConfig} svelte_config
- * @param {Set<string>} illegal_imports
  * @return {Promise<Promise<() => void>>}
  */
-export async function dev(vite, vite_config, svelte_config, illegal_imports) {
+export async function dev(vite, vite_config, svelte_config) {
 	installPolyfills();
 
 	sync.init(svelte_config, vite_config.mode);
@@ -90,7 +90,11 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 								module_nodes.push(module_node);
 								result.file = url.endsWith('.svelte') ? url : url + '?import'; // TODO what is this for?
 
-								prevent_illegal_vite_imports(module_node, illegal_imports, extensions);
+								prevent_illegal_vite_imports(
+									module_node,
+									normalizePath(svelte_config.kit.files.lib),
+									extensions
+								);
 
 								return module.default;
 							};
@@ -103,7 +107,11 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 
 							result.shared = module;
 
-							prevent_illegal_vite_imports(module_node, illegal_imports, extensions);
+							prevent_illegal_vite_imports(
+								module_node,
+								normalizePath(svelte_config.kit.files.lib),
+								extensions
+							);
 						}
 
 						if (node.server) {
@@ -407,7 +415,6 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 						},
 						hooks,
 						manifest,
-						method_override: svelte_config.kit.methodOverride,
 						paths: {
 							base: svelte_config.kit.paths.base,
 							assets

package/src/exports/vite/index.js

@@ -103,9 +103,6 @@ function kit() {
 	/** @type {import('types').BuildData} */
 	let build_data;
 
-	/** @type {Set<string>} */
-	let illegal_imports;
-
 	/** @type {string | undefined} */
 	let deferred_warning;
 
@@ -212,13 +209,6 @@ function kit() {
 				client_out_dir: `${svelte_config.kit.outDir}/output/client`
 			};
 
-			illegal_imports = new Set([
-				'/@id/__x00__$env/dynamic/private', //dev
-				'\0$env/dynamic/private', // prod
-				'/@id/__x00__$env/static/private', // dev
-				'\0$env/static/private' // prod
-			]);
-
 			if (is_build) {
 				manifest_data = (await sync.all(svelte_config, config_env.mode)).manifest_data;
 
@@ -361,7 +351,7 @@ function kit() {
 						prevent_illegal_rollup_imports(
 							this.getModuleInfo.bind(this),
 							module_node,
-							illegal_imports
+							vite.normalizePath(svelte_config.kit.files.lib)
 						);
 					}
 				});
@@ -517,7 +507,7 @@ function kit() {
 				if (deferred_warning) console.error('\n' + deferred_warning);
 			};
 
-			return await dev(vite, vite_config, svelte_config, illegal_imports);
+			return await dev(vite, vite_config, svelte_config);
 		},
 
 		/**

package/src/exports/vite/utils.js

@@ -4,6 +4,26 @@ import { loadConfigFromFile, loadEnv, normalizePath } from 'vite';
 import { runtime_directory } from '../../core/utils.js';
 import { posixify } from '../../utils/filesystem.js';
 
+const illegal_imports = new Set([
+	'/@id/__x00__$env/dynamic/private', //dev
+	'\0$env/dynamic/private', // prod
+	'/@id/__x00__$env/static/private', // dev
+	'\0$env/static/private' // prod
+]);
+
+/** @param {string} id */
+function is_illegal(id) {
+	if (illegal_imports.has(id)) return true;
+
+	// files outside the project root are ignored
+	if (!id.startsWith(normalizePath(process.cwd()))) return false;
+
+	// so are files inside node_modules
+	if (id.startsWith(normalizePath(node_modules_dir))) return false;
+
+	return /.*\.server\..+/.test(path.basename(id));
+}
+
 /**
  * @param {import('vite').ResolvedConfig} config
  * @param {import('vite').ConfigEnv} config_env
@@ -183,8 +203,9 @@ function repeat(str, times) {
 /**
  * Create a formatted error for an illegal import.
  * @param {Array<{name: string, dynamic: boolean}>} stack
+ * @param {string} lib_dir
  */
-function format_illegal_import_chain(stack) {
+function format_illegal_import_chain(stack, lib_dir) {
 	const dev_virtual_prefix = '/@id/__x00__';
 	const prod_virtual_prefix = '\0';
 
@@ -195,6 +216,9 @@ function format_illegal_import_chain(stack) {
 		if (file.name.startsWith(prod_virtual_prefix)) {
 			return { ...file, name: file.name.replace(prod_virtual_prefix, '') };
 		}
+		if (file.name.startsWith(lib_dir)) {
+			return { ...file, name: file.name.replace(lib_dir, '$lib') };
+		}
 
 		return { ...file, name: path.relative(process.cwd(), file.name) };
 	});
@@ -211,6 +235,8 @@ function format_illegal_import_chain(stack) {
 	return `Cannot import ${stack.at(-1)?.name} into client-side code:\n${pyramid}`;
 }
 
+const node_modules_dir = path.resolve(process.cwd(), 'node_modules');
+
 /**
  * Load environment variables from process.env and .env files
  * @param {import('types').ValidatedKitConfig['env']} env_config
@@ -228,11 +254,11 @@ export function get_env(env_config, mode) {
 /**
  * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
  * @param {import('rollup').ModuleInfo} node
- * @param {Set<string>} illegal_imports Illegal module IDs -- be sure to call vite.normalizePath!
+ * @param {string} lib_dir
  */
-export function prevent_illegal_rollup_imports(node_getter, node, illegal_imports) {
-	const chain = find_illegal_rollup_imports(node_getter, node, false, illegal_imports);
-	if (chain) throw new Error(format_illegal_import_chain(chain));
+export function prevent_illegal_rollup_imports(node_getter, node, lib_dir) {
+	const chain = find_illegal_rollup_imports(node_getter, node, false);
+	if (chain) throw new Error(format_illegal_import_chain(chain, lib_dir));
 }
 
 const query_pattern = /\?.*$/s;
@@ -246,36 +272,27 @@ function remove_query_from_path(path) {
  * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
  * @param {import('rollup').ModuleInfo} node
  * @param {boolean} dynamic
- * @param {Set<string>} illegal_imports Illegal module IDs -- be sure to call vite.normalizePath!
  * @param {Set<string>} seen
  * @returns {Array<import('types').ImportNode> | null}
  */
-const find_illegal_rollup_imports = (
-	node_getter,
-	node,
-	dynamic,
-	illegal_imports,
-	seen = new Set()
-) => {
+const find_illegal_rollup_imports = (node_getter, node, dynamic, seen = new Set()) => {
 	const name = remove_query_from_path(normalizePath(node.id));
 	if (seen.has(name)) return null;
 	seen.add(name);
 
-	if (illegal_imports.has(name)) {
+	if (is_illegal(name)) {
 		return [{ name, dynamic }];
 	}
 
 	for (const id of node.importedIds) {
 		const child = node_getter(id);
-		const chain =
-			child && find_illegal_rollup_imports(node_getter, child, false, illegal_imports, seen);
+		const chain = child && find_illegal_rollup_imports(node_getter, child, false, seen);
 		if (chain) return [{ name, dynamic }, ...chain];
 	}
 
 	for (const id of node.dynamicallyImportedIds) {
 		const child = node_getter(id);
-		const chain =
-			child && find_illegal_rollup_imports(node_getter, child, true, illegal_imports, seen);
+		const chain = child && find_illegal_rollup_imports(node_getter, child, true, seen);
 		if (chain) return [{ name, dynamic }, ...chain];
 	}
 
@@ -308,22 +325,21 @@ const get_module_types = (config_module_types) => {
 /**
  * Throw an error if a private module is imported from a client-side node.
  * @param {import('vite').ModuleNode} node
- * @param {Set<string>} illegal_imports Illegal module IDs -- be sure to call vite.normalizePath!
+ * @param {string} lib_dir
  * @param {Iterable<string>} module_types File extensions to analyze in addition to the defaults: `.ts`, `.js`, etc.
  */
-export function prevent_illegal_vite_imports(node, illegal_imports, module_types) {
-	const chain = find_illegal_vite_imports(node, illegal_imports, get_module_types(module_types));
-	if (chain) throw new Error(format_illegal_import_chain(chain));
+export function prevent_illegal_vite_imports(node, lib_dir, module_types) {
+	const chain = find_illegal_vite_imports(node, get_module_types(module_types));
+	if (chain) throw new Error(format_illegal_import_chain(chain, lib_dir));
 }
 
 /**
  * @param {import('vite').ModuleNode} node
- * @param {Set<string>} illegal_imports Illegal module IDs -- be sure to call vite.normalizePath!
  * @param {Set<string>} module_types File extensions to analyze: `.ts`, `.js`, etc.
  * @param {Set<string>} seen
  * @returns {Array<import('types').ImportNode> | null}
  */
-function find_illegal_vite_imports(node, illegal_imports, module_types, seen = new Set()) {
+function find_illegal_vite_imports(node, module_types, seen = new Set()) {
 	if (!node.id) return null; // TODO when does this happen?
 	const name = remove_query_from_path(normalizePath(node.id));
 
@@ -332,12 +348,12 @@ function find_illegal_vite_imports(node, illegal_imports, module_types, seen = n
 	}
 	seen.add(name);
 
-	if (name && illegal_imports.has(name)) {
+	if (is_illegal(name)) {
 		return [{ name, dynamic: false }];
 	}
 
 	for (const child of node.importedModules) {
-		const chain = child && find_illegal_vite_imports(child, illegal_imports, module_types, seen);
+		const chain = child && find_illegal_vite_imports(child, module_types, seen);
 		if (chain) return [{ name, dynamic: false }, ...chain];
 	}