astro 6.0.0-alpha.1 → 6.0.0-alpha.2

package/dist/content/vite-plugin-content-assets.js

@@ -2,7 +2,6 @@ import { extname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isRunnableDevEnvironment } from "vite";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { createViteLoader } from "../core/module-loader/vite.js";
 import { wrapId } from "../core/util.js";
 import { isBuildableCSSRequest } from "../vite-plugin-astro-server/util.js";
 import { crawlGraph } from "../vite-plugin-astro-server/vite.js";
@@ -20,72 +19,78 @@ import { isAstroServerEnvironment } from "../environments.js";
 function astroContentAssetPropagationPlugin({
   settings
 }) {
-  let devModuleLoader;
+  let environment = void 0;
   return {
     name: "astro:content-asset-propagation",
     enforce: "pre",
-    async resolveId(id, importer, opts) {
-      if (hasContentFlag(id, CONTENT_IMAGE_FLAG)) {
-        const [base, query] = id.split("?");
-        const params = new URLSearchParams(query);
-        const importerParam = params.get("importer");
-        const importerPath = importerParam ? fileURLToPath(new URL(importerParam, settings.config.root)) : importer;
-        const resolved = await this.resolve(base, importerPath, { skipSelf: true, ...opts });
-        if (!resolved) {
-          throw new AstroError({
-            ...AstroErrorData.ImageNotFound,
-            message: AstroErrorData.ImageNotFound.message(base)
-          });
-        }
-        return resolved;
-      }
-      if (hasContentFlag(id, CONTENT_RENDER_FLAG)) {
-        const base = id.split("?")[0];
-        for (const { extensions, handlePropagation = true } of settings.contentEntryTypes) {
-          if (handlePropagation && extensions.includes(extname(base))) {
-            return this.resolve(`${base}?${PROPAGATED_ASSET_FLAG}`, importer, {
-              skipSelf: true,
-              ...opts
+    resolveId: {
+      filter: {
+        id: new RegExp(`(?:\\?|&)(?:${CONTENT_IMAGE_FLAG}|${CONTENT_RENDER_FLAG})(?:&|=|$)`)
+      },
+      async handler(id, importer, opts) {
+        if (hasContentFlag(id, CONTENT_IMAGE_FLAG)) {
+          const [base, query] = id.split("?");
+          const params = new URLSearchParams(query);
+          const importerParam = params.get("importer");
+          const importerPath = importerParam ? fileURLToPath(new URL(importerParam, settings.config.root)) : importer;
+          const resolved = await this.resolve(base, importerPath, { skipSelf: true, ...opts });
+          if (!resolved) {
+            throw new AstroError({
+              ...AstroErrorData.ImageNotFound,
+              message: AstroErrorData.ImageNotFound.message(base)
             });
           }
+          return resolved;
+        }
+        if (hasContentFlag(id, CONTENT_RENDER_FLAG)) {
+          const base = id.split("?")[0];
+          for (const { extensions, handlePropagation = true } of settings.contentEntryTypes) {
+            if (handlePropagation && extensions.includes(extname(base))) {
+              return this.resolve(`${base}?${PROPAGATED_ASSET_FLAG}`, importer, {
+                skipSelf: true,
+                ...opts
+              });
+            }
+          }
+          return this.resolve(base, importer, { skipSelf: true, ...opts });
         }
-        return this.resolve(base, importer, { skipSelf: true, ...opts });
       }
     },
     configureServer(server) {
       if (!isRunnableDevEnvironment(server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
         return;
       }
-      devModuleLoader = createViteLoader(
-        server,
-        server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]
-      );
+      environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
     },
-    async transform(_, id) {
-      if (hasContentFlag(id, PROPAGATED_ASSET_FLAG)) {
-        const basePath = id.split("?")[0];
-        let stringifiedLinks, stringifiedStyles;
-        if (isAstroServerEnvironment(this.environment) && devModuleLoader) {
-          if (!devModuleLoader.getModuleById(basePath)?.ssrModule) {
-            await devModuleLoader.import(basePath);
-          }
-          const {
-            styles,
-            urls,
-            crawledFiles: styleCrawledFiles
-          } = await getStylesForURL(basePath, devModuleLoader.getSSREnvironment());
-          for (const file of styleCrawledFiles) {
-            if (!file.includes("node_modules")) {
-              this.addWatchFile(file);
+    transform: {
+      filter: {
+        id: new RegExp(`(?:\\?|&)${PROPAGATED_ASSET_FLAG}(?:&|=|$)`)
+      },
+      async handler(_, id) {
+        if (hasContentFlag(id, PROPAGATED_ASSET_FLAG)) {
+          const basePath = id.split("?")[0];
+          let stringifiedLinks, stringifiedStyles;
+          if (isAstroServerEnvironment(this.environment) && environment) {
+            if (!environment.moduleGraph.getModuleById(basePath)?.ssrModule) {
+              await environment.runner.import(basePath);
+            }
+            const {
+              styles,
+              urls,
+              crawledFiles: styleCrawledFiles
+            } = await getStylesForURL(basePath, environment);
+            for (const file of styleCrawledFiles) {
+              if (!file.includes("node_modules")) {
+                this.addWatchFile(file);
+              }
             }
+            stringifiedLinks = JSON.stringify([...urls]);
+            stringifiedStyles = JSON.stringify(styles.map((s) => s.content));
+          } else {
+            stringifiedLinks = JSON.stringify(LINKS_PLACEHOLDER);
+            stringifiedStyles = JSON.stringify(STYLES_PLACEHOLDER);
           }
-          stringifiedLinks = JSON.stringify([...urls]);
-          stringifiedStyles = JSON.stringify(styles.map((s) => s.content));
-        } else {
-          stringifiedLinks = JSON.stringify(LINKS_PLACEHOLDER);
-          stringifiedStyles = JSON.stringify(STYLES_PLACEHOLDER);
-        }
-        const code = `
+          const code = `
 					async function getMod() {
 						return import(${JSON.stringify(basePath)});
 					}
@@ -94,7 +99,8 @@ function astroContentAssetPropagationPlugin({
 					const defaultMod = { __astroPropagation: true, getMod, collectedLinks, collectedStyles, collectedScripts: [] };
 					export default defaultMod;
 				`;
-        return { code, map: { mappings: "" } };
+          return { code, map: { mappings: "" } };
+        }
       }
     }
   };

package/dist/content/vite-plugin-content-imports.js

@@ -57,23 +57,27 @@ function astroContentImportPlugin({
       async buildStart() {
         symlinks = await getSymlinkedContentCollections({ contentDir, logger, fs });
       },
-      async transform(_, viteId) {
-        if (hasContentFlag(viteId, DATA_FLAG)) {
-          const fileId = reverseSymlink({
-            entry: viteId.split("?")[0] ?? viteId,
-            contentDir,
-            symlinks
-          });
-          const { id, data, collection, _internal } = await getDataEntryModule({
-            fileId,
-            entryConfigByExt: dataEntryConfigByExt,
-            contentDir,
-            config: settings.config,
-            fs,
-            pluginContext: this,
-            shouldEmitFile
-          });
-          const code = `
+      transform: {
+        filter: {
+          id: new RegExp(`(?:\\?|&)(?:${DATA_FLAG}|${CONTENT_FLAG})(?:&|=|$)`)
+        },
+        async handler(_, viteId) {
+          if (hasContentFlag(viteId, DATA_FLAG)) {
+            const fileId = reverseSymlink({
+              entry: viteId.split("?")[0] ?? viteId,
+              contentDir,
+              symlinks
+            });
+            const { id, data, collection, _internal } = await getDataEntryModule({
+              fileId,
+              entryConfigByExt: dataEntryConfigByExt,
+              contentDir,
+              config: settings.config,
+              fs,
+              pluginContext: this,
+              shouldEmitFile
+            });
+            const code = `
 export const id = ${JSON.stringify(id)};
 export const collection = ${JSON.stringify(collection)};
 export const data = ${stringifyEntryData(data, settings.buildOutput === "server")};
@@ -83,19 +87,19 @@ export const _internal = {
 	rawData: ${JSON.stringify(_internal.rawData)},
 };
 `;
-          return code;
-        } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
-          const fileId = reverseSymlink({ entry: viteId.split("?")[0], contentDir, symlinks });
-          const { id, slug, collection, body, data, _internal } = await getContentEntryModule({
-            fileId,
-            entryConfigByExt: contentEntryConfigByExt,
-            contentDir,
-            config: settings.config,
-            fs,
-            pluginContext: this,
-            shouldEmitFile
-          });
-          const code = `
+            return code;
+          } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
+            const fileId = reverseSymlink({ entry: viteId.split("?")[0], contentDir, symlinks });
+            const { id, slug, collection, body, data, _internal } = await getContentEntryModule({
+              fileId,
+              entryConfigByExt: contentEntryConfigByExt,
+              contentDir,
+              config: settings.config,
+              fs,
+              pluginContext: this,
+              shouldEmitFile
+            });
+            const code = `
 						export const id = ${JSON.stringify(id)};
 						export const collection = ${JSON.stringify(collection)};
 						export const slug = ${JSON.stringify(slug)};
@@ -106,7 +110,8 @@ export const _internal = {
 							filePath: ${JSON.stringify(_internal.filePath)},
 							rawData: ${JSON.stringify(_internal.rawData)},
 						};`;
-          return { code, map: { mappings: "" } };
+            return { code, map: { mappings: "" } };
+          }
         }
       },
       configureServer(viteServer) {
@@ -143,11 +148,18 @@ export const _internal = {
   if (settings.contentEntryTypes.some((t) => t.getRenderModule)) {
     plugins.push({
       name: "astro:content-render-imports",
-      async transform(contents, viteId) {
-        const contentRenderer = getContentRendererByViteId(viteId, settings);
-        if (!contentRenderer) return;
-        const fileId = viteId.split("?")[0];
-        return contentRenderer.bind(this)({ viteId, contents, fileUrl: pathToFileURL(fileId) });
+      transform: {
+        filter: {
+          id: {
+            include: settings.contentEntryTypes.filter((t) => t.getRenderModule).map((t) => new RegExp(`\\.(${t.extensions.map((e) => e.slice(1)).join("|")})$`))
+          }
+        },
+        async handler(contents, viteId) {
+          const contentRenderer = getContentRendererByViteId(viteId, settings);
+          if (!contentRenderer) return;
+          const fileId = viteId.split("?")[0];
+          return contentRenderer.bind(this)({ viteId, contents, fileUrl: pathToFileURL(fileId) });
+        }
       }
     });
   }

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -1,15 +1,17 @@
-import { dataToEsm } from "@rollup/pluginutils";
 import nodeFs from "node:fs";
 import { fileURLToPath } from "node:url";
+import { dataToEsm } from "@rollup/pluginutils";
 import { normalizePath } from "vite";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/viteUtils.js";
+import { isAstroClientEnvironment } from "../environments.js";
 import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
 import {
   ASSET_IMPORTS_FILE,
   ASSET_IMPORTS_RESOLVED_STUB_ID,
   ASSET_IMPORTS_VIRTUAL_ID,
+  CONTENT_MODULE_FLAG,
   CONTENT_RENDER_FLAG,
   DATA_STORE_VIRTUAL_ID,
   MODULES_IMPORTS_FILE,
@@ -21,7 +23,6 @@ import {
 } from "./consts.js";
 import { getDataStoreFile } from "./content-layer.js";
 import { getContentPaths, isDeferredModule } from "./utils.js";
-import { isAstroClientEnvironment } from "../environments.js";
 function invalidateDataStore(viteServer) {
   const environment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
   const module = environment.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
@@ -56,91 +57,105 @@ function astroContentVirtualModPlugin({
         invalidateDataStore(devServer);
       }
     },
-    async resolveId(id, importer) {
-      if (id === VIRTUAL_MODULE_ID) {
-        if (liveConfig && importer && liveConfig === normalizePath(importer)) {
-          return this.resolve("astro/virtual-modules/live-config", importer, {
-            skipSelf: true
-          });
+    resolveId: {
+      filter: {
+        id: new RegExp(
+          `^(${VIRTUAL_MODULE_ID}|${DATA_STORE_VIRTUAL_ID}|${MODULES_MJS_ID}|${ASSET_IMPORTS_VIRTUAL_ID})$|(?:\\?|&)${CONTENT_MODULE_FLAG}(?:&|=|$)`
+        )
+      },
+      async handler(id, importer) {
+        if (id === VIRTUAL_MODULE_ID) {
+          if (liveConfig && importer && liveConfig === normalizePath(importer)) {
+            return this.resolve("astro/virtual-modules/live-config", importer, {
+              skipSelf: true
+            });
+          }
+          return RESOLVED_VIRTUAL_MODULE_ID;
         }
-        return RESOLVED_VIRTUAL_MODULE_ID;
-      }
-      if (id === DATA_STORE_VIRTUAL_ID) {
-        return RESOLVED_DATA_STORE_VIRTUAL_ID;
-      }
-      if (isDeferredModule(id)) {
-        const [, query] = id.split("?");
-        const params = new URLSearchParams(query);
-        const fileName = params.get("fileName");
-        let importPath = void 0;
-        if (fileName && URL.canParse(fileName, settings.config.root.toString())) {
-          importPath = fileURLToPath(new URL(fileName, settings.config.root));
+        if (id === DATA_STORE_VIRTUAL_ID) {
+          return RESOLVED_DATA_STORE_VIRTUAL_ID;
         }
-        if (importPath) {
-          return await this.resolve(`${importPath}?${CONTENT_RENDER_FLAG}`);
+        if (isDeferredModule(id)) {
+          const [, query] = id.split("?");
+          const params = new URLSearchParams(query);
+          const fileName = params.get("fileName");
+          let importPath = void 0;
+          if (fileName && URL.canParse(fileName, settings.config.root.toString())) {
+            importPath = fileURLToPath(new URL(fileName, settings.config.root));
+          }
+          if (importPath) {
+            return await this.resolve(`${importPath}?${CONTENT_RENDER_FLAG}`);
+          }
         }
-      }
-      if (id === MODULES_MJS_ID) {
-        const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
-        if (fs.existsSync(modules)) {
-          return fileURLToPath(modules);
+        if (id === MODULES_MJS_ID) {
+          const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
+          if (fs.existsSync(modules)) {
+            return fileURLToPath(modules);
+          }
+          return MODULES_MJS_VIRTUAL_ID;
         }
-        return MODULES_MJS_VIRTUAL_ID;
-      }
-      if (id === ASSET_IMPORTS_VIRTUAL_ID) {
-        const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
-        if (fs.existsSync(assetImportsFile)) {
-          return fileURLToPath(assetImportsFile);
+        if (id === ASSET_IMPORTS_VIRTUAL_ID) {
+          const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
+          if (fs.existsSync(assetImportsFile)) {
+            return fileURLToPath(assetImportsFile);
+          }
+          return ASSET_IMPORTS_RESOLVED_STUB_ID;
         }
-        return ASSET_IMPORTS_RESOLVED_STUB_ID;
       }
     },
-    async load(id) {
-      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-        const isClient = isAstroClientEnvironment(this.environment);
-        const code = await generateContentEntryFile({
-          settings,
-          fs,
-          isClient
-        });
-        const astro = createDefaultAstroMetadata();
-        astro.propagation = "in-tree";
-        return {
-          code,
-          meta: {
-            astro
+    load: {
+      filter: {
+        id: new RegExp(
+          `^(${RESOLVED_VIRTUAL_MODULE_ID}|${RESOLVED_DATA_STORE_VIRTUAL_ID}|${ASSET_IMPORTS_RESOLVED_STUB_ID}|${MODULES_MJS_VIRTUAL_ID})$`
+        )
+      },
+      async handler(id) {
+        if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+          const isClient = isAstroClientEnvironment(this.environment);
+          const code = await generateContentEntryFile({
+            settings,
+            fs,
+            isClient
+          });
+          const astro = createDefaultAstroMetadata();
+          astro.propagation = "in-tree";
+          return {
+            code,
+            meta: {
+              astro
+            }
+          };
+        }
+        if (id === RESOLVED_DATA_STORE_VIRTUAL_ID) {
+          if (!fs.existsSync(dataStoreFile)) {
+            return { code: "export default new Map()" };
+          }
+          const jsonData = await fs.promises.readFile(dataStoreFile, "utf-8");
+          try {
+            const parsed = JSON.parse(jsonData);
+            return {
+              code: dataToEsm(parsed, {
+                compact: true
+              }),
+              map: { mappings: "" }
+            };
+          } catch (err) {
+            const message = "Could not parse JSON file";
+            this.error({ message, id, cause: err });
           }
-        };
-      }
-      if (id === RESOLVED_DATA_STORE_VIRTUAL_ID) {
-        if (!fs.existsSync(dataStoreFile)) {
-          return { code: "export default new Map()" };
         }
-        const jsonData = await fs.promises.readFile(dataStoreFile, "utf-8");
-        try {
-          const parsed = JSON.parse(jsonData);
+        if (id === ASSET_IMPORTS_RESOLVED_STUB_ID) {
+          const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
           return {
-            code: dataToEsm(parsed, {
-              compact: true
-            }),
-            map: { mappings: "" }
+            code: fs.existsSync(assetImportsFile) ? fs.readFileSync(assetImportsFile, "utf-8") : "export default new Map()"
+          };
+        }
+        if (id === MODULES_MJS_VIRTUAL_ID) {
+          const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
+          return {
+            code: fs.existsSync(modules) ? fs.readFileSync(modules, "utf-8") : "export default new Map()"
           };
-        } catch (err) {
-          const message = "Could not parse JSON file";
-          this.error({ message, id, cause: err });
         }
-      }
-      if (id === ASSET_IMPORTS_RESOLVED_STUB_ID) {
-        const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
-        return {
-          code: fs.existsSync(assetImportsFile) ? fs.readFileSync(assetImportsFile, "utf-8") : "export default new Map()"
-        };
-      }
-      if (id === MODULES_MJS_VIRTUAL_ID) {
-        const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
-        return {
-          code: fs.existsSync(modules) ? fs.readFileSync(modules, "utf-8") : "export default new Map()"
-        };
       }
     },
     configureServer(server) {

package/dist/core/app/validate-forwarded-headers.d.ts

@@ -1,4 +1,4 @@
-import { type RemotePattern } from '../../assets/utils/remotePattern.js';
+import { type RemotePattern } from '@astrojs/internal-helpers/remote';
 /**
  * Validate a hostname by rejecting any with path separators.
  * Prevents path injection attacks. Invalid hostnames return undefined.

package/dist/core/app/validate-forwarded-headers.js

@@ -1,4 +1,4 @@
-import { matchPattern } from "../../assets/utils/remotePattern.js";
+import { matchPattern } from "@astrojs/internal-helpers/remote";
 function sanitizeHost(hostname) {
   if (!hostname) return void 0;
   if (/[/\\]/.test(hostname)) return void 0;

package/dist/core/build/plugins/plugin-component-entry.js

@@ -38,13 +38,19 @@ function pluginComponentEntry(internals) {
         });
       }
     },
-    async resolveId(id) {
-      if (id.startsWith(astroEntryPrefix)) {
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${astroEntryPrefix}`)
+      },
+      handler(id) {
         return id;
       }
     },
-    async load(id) {
-      if (id.startsWith(astroEntryPrefix)) {
+    load: {
+      filter: {
+        id: new RegExp(`^${astroEntryPrefix}`)
+      },
+      async handler(id) {
         const componentId = id.slice(astroEntryPrefix.length);
         const exportNames = componentToExportNames.get(componentId);
         if (exportNames) {

package/dist/core/build/plugins/plugin-css.js

@@ -8,6 +8,7 @@ import {
 import { getPageDataByViteID, getPageDatasByClientOnlyID } from "../internal.js";
 import { shouldInlineAsset } from "./util.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+import { CSS_LANGS_RE } from "../../viteUtils.js";
 function pluginCSS(options, internals) {
   return rollupPluginAstroBuildCSS({
     buildOptions: options,
@@ -26,8 +27,11 @@ function rollupPluginAstroBuildCSS(options) {
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
     },
-    transform(_code, id) {
-      if (isCSSRequest(id)) {
+    transform: {
+      filter: {
+        id: CSS_LANGS_RE
+      },
+      handler(_code, id) {
         if (this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender) {
           if (cssModulesInBundles.has(id)) {
             return {

package/dist/core/build/plugins/plugin-noop.js

@@ -3,13 +3,19 @@ const RESOLVED_NOOP_MODULE_ID = "\0" + NOOP_MODULE_ID;
 function pluginNoop() {
   return {
     name: "plugin-noop",
-    resolveId(id) {
-      if (id === NOOP_MODULE_ID) {
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${NOOP_MODULE_ID}$`)
+      },
+      handler() {
         return RESOLVED_NOOP_MODULE_ID;
       }
     },
-    load(id) {
-      if (id === RESOLVED_NOOP_MODULE_ID) {
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_NOOP_MODULE_ID}$`)
+      },
+      handler() {
         return "export const noop = {};";
       }
     },

package/dist/core/build/plugins/plugin-ssr.js

@@ -12,13 +12,19 @@ function vitePluginAdapter(adapter) {
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
     },
-    resolveId(id) {
-      if (id === ADAPTER_VIRTUAL_MODULE_ID) {
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${ADAPTER_VIRTUAL_MODULE_ID}$`)
+      },
+      handler() {
         return RESOLVED_ADAPTER_VIRTUAL_MODULE_ID;
       }
     },
-    async load(id) {
-      if (id === RESOLVED_ADAPTER_VIRTUAL_MODULE_ID) {
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_ADAPTER_VIRTUAL_MODULE_ID}$`)
+      },
+      async handler() {
         const adapterEntrypointStr = JSON.stringify(adapter.serverEntrypoint);
         return {
           code: `export * from ${adapterEntrypointStr};
@@ -36,13 +42,19 @@ function vitePluginAdapterConfig(adapter) {
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
     },
-    resolveId(id) {
-      if (id === ADAPTER_CONFIG_VIRTUAL_MODULE_ID) {
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${ADAPTER_CONFIG_VIRTUAL_MODULE_ID}$`)
+      },
+      handler() {
         return RESOLVED_ADAPTER_CONFIG_VIRTUAL_MODULE_ID;
       }
     },
-    load(id) {
-      if (id === RESOLVED_ADAPTER_CONFIG_VIRTUAL_MODULE_ID) {
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_ADAPTER_CONFIG_VIRTUAL_MODULE_ID}$`)
+      },
+      handler() {
         return {
           code: `export const args = ${adapter.args ? JSON.stringify(adapter.args, null, 2) : "undefined"};
 export const exports = ${adapter.exports ? JSON.stringify(adapter.exports) : "undefined"};
@@ -60,13 +72,19 @@ function vitePluginSSR(internals, adapter) {
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
     },
-    resolveId(id) {
-      if (id === SSR_VIRTUAL_MODULE_ID) {
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${SSR_VIRTUAL_MODULE_ID}$`)
+      },
+      handler() {
         return RESOLVED_SSR_VIRTUAL_MODULE_ID;
       }
     },
-    load(id) {
-      if (id === RESOLVED_SSR_VIRTUAL_MODULE_ID) {
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_SSR_VIRTUAL_MODULE_ID}$`)
+      },
+      handler() {
         const exports = [];
         if (adapter.exports) {
           exports.push(

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.0.0-alpha.1";
+const ASTRO_VERSION = "6.0.0-alpha.2";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";

package/dist/core/create-vite.js

@@ -23,10 +23,7 @@ import astroTransitions from "../transitions/vite-plugin-transitions.js";
 import { vitePluginAdapterConfig } from "../vite-plugin-adapter-config/index.js";
 import { vitePluginApp } from "../vite-plugin-app/index.js";
 import astroVitePlugin from "../vite-plugin-astro/index.js";
-import {
-  vitePluginAstroServer,
-  vitePluginAstroServerClient
-} from "../vite-plugin-astro-server/index.js";
+import { vitePluginAstroServer } from "../vite-plugin-astro-server/index.js";
 import configAliasVitePlugin from "../vite-plugin-config-alias/index.js";
 import { astroDevCssPlugin } from "../vite-plugin-css/index.js";
 import vitePluginFileURL from "../vite-plugin-fileurl/index.js";
@@ -49,6 +46,8 @@ import { vitePluginSessionDriver } from "./session/vite-plugin.js";
 import { isObject } from "./util.js";
 import { vitePluginEnvironment } from "../vite-plugin-environment/index.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "./constants.js";
+import { vitePluginChromedevtools } from "../vite-plugin-chromedevtools/index.js";
+import { vitePluginAstroServerClient } from "../vite-plugin-overlay/index.js";
 async function createVite(commandConfig, { settings, logger, mode, command, fs = nodeFs, sync, routesList }) {
   const astroPkgsConfig = await crawlFrameworkPkgs({
     root: fileURLToPath(settings.config.root),
@@ -128,7 +127,8 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       vitePluginServerIslands({ settings, logger }),
       vitePluginSessionDriver({ settings }),
       astroContainer(),
-      astroHmrReloadPlugin()
+      astroHmrReloadPlugin(),
+      vitePluginChromedevtools({ settings })
     ],
     publicDir: fileURLToPath(settings.config.publicDir),
     root: fileURLToPath(settings.config.root),