astro 4.4.0 → 4.4.1

package/dist/vite-plugin-astro/hmr.js

@@ -18,7 +18,7 @@ async function handleHotUpdate(ctx, { logger, compile, astroFileToCssAstroDeps,
           ctx.server.moduleGraph.invalidateModule(mod);
         }
       }
-      ctx.server.ws.send({ type: "full-reload", path: "*" });
+      ctx.server.hot.send({ type: "full-reload", path: "*" });
     }
   }
 }
@@ -41,8 +41,10 @@ function isStyleOnlyChanged(oldCode, newCode) {
     return false;
   const oldStyles = [];
   const newStyles = [];
-  oldCode.match(styleRE)?.forEach((m) => oldStyles.push(m));
-  newCode.match(styleRE)?.forEach((m) => newStyles.push(m));
+  oldCode = oldCode.replace(styleRE, (m) => (oldStyles.push(m), ""));
+  newCode = newCode.replace(styleRE, (m) => (newStyles.push(m), ""));
+  if (oldCode !== newCode)
+    return false;
   return oldStyles.length === newStyles.length && !isArrayEqual(oldStyles, newStyles);
 }
 function isArrayEqual(a, b) {
@@ -60,5 +62,6 @@ function getShortName(file, root) {
   return file.startsWith(appendForwardSlash(root)) ? path.posix.relative(root, file) : file;
 }
 export {
-  handleHotUpdate
+  handleHotUpdate,
+  isStyleOnlyChanged
 };

package/dist/vite-plugin-astro-server/error.d.ts

@@ -1,7 +1,7 @@
 import type { ModuleLoader } from '../core/module-loader/index.js';
 import type { AstroConfig } from '../@types/astro.js';
-import type DevPipeline from './devPipeline.js';
-export declare function recordServerError(loader: ModuleLoader, config: AstroConfig, pipeline: DevPipeline, _err: unknown): {
+import type { DevPipeline } from './pipeline.js';
+export declare function recordServerError(loader: ModuleLoader, config: AstroConfig, { logger }: DevPipeline, _err: unknown): {
     error: Error;
     errorWithMetadata: import("../core/errors/errors.js").ErrorWithMetadata;
 };

package/dist/vite-plugin-astro-server/error.js

@@ -2,7 +2,7 @@ import { collectErrorMetadata } from "../core/errors/dev/index.js";
 import { createSafeError, AstroErrorData } from "../core/errors/index.js";
 import { formatErrorMessage } from "../core/messages.js";
 import { eventError, telemetry } from "../events/index.js";
-function recordServerError(loader, config, pipeline, _err) {
+function recordServerError(loader, config, { logger }, _err) {
   const err = createSafeError(_err);
   try {
     loader.fixStacktrace(err);
@@ -12,10 +12,7 @@ function recordServerError(loader, config, pipeline, _err) {
   if (errorWithMetadata.name !== AstroErrorData.UnhandledRejection.name) {
     telemetry.record(eventError({ cmd: "dev", err: errorWithMetadata, isFatal: false }));
   }
-  pipeline.logger.error(
-    null,
-    formatErrorMessage(errorWithMetadata, pipeline.logger.level() === "debug")
-  );
+  logger.error(null, formatErrorMessage(errorWithMetadata, logger.level() === "debug"));
   return {
     error: err,
     errorWithMetadata

package/dist/vite-plugin-astro-server/index.d.ts

@@ -1,9 +1,3 @@
-import type { ComponentInstance } from '../@types/astro.js';
-import type DevPipeline from './devPipeline.js';
-export declare function preload({ pipeline, filePath, }: {
-    pipeline: DevPipeline;
-    filePath: URL;
-}): Promise<ComponentInstance>;
 export { createController, runWithErrorHandling } from './controller.js';
 export { default as vitePluginAstroServer } from './plugin.js';
 export { handleRequest } from './request.js';

package/dist/vite-plugin-astro-server/index.js

@@ -1,28 +1,9 @@
-import { enhanceViteSSRError } from "../core/errors/dev/index.js";
-import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
-import { viteID } from "../core/util.js";
-async function preload({
-  pipeline,
-  filePath
-}) {
-  await pipeline.loadRenderers();
-  try {
-    const mod = await pipeline.getModuleLoader().import(viteID(filePath));
-    return mod;
-  } catch (error) {
-    if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
-      throw error;
-    }
-    throw enhanceViteSSRError({ error, filePath, loader: pipeline.getModuleLoader() });
-  }
-}
 import { createController, runWithErrorHandling } from "./controller.js";
 import { default as default2 } from "./plugin.js";
 import { handleRequest } from "./request.js";
 export {
   createController,
   handleRequest,
-  preload,
   runWithErrorHandling,
   default2 as vitePluginAstroServer
 };

package/dist/vite-plugin-astro-server/pipeline.d.ts

@@ -0,0 +1,19 @@
+import type { AstroSettings, ComponentInstance, RouteData, SSRLoadedRenderer, SSRManifest } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import { Pipeline } from '../core/render/index.js';
+import type { HeadElements } from '../core/base-pipeline.js';
+export declare class DevPipeline extends Pipeline {
+    readonly loader: ModuleLoader;
+    readonly logger: Logger;
+    readonly manifest: SSRManifest;
+    readonly settings: AstroSettings;
+    readonly config: import("../@types/astro.js").AstroConfig;
+    renderers: SSRLoadedRenderer[];
+    private constructor();
+    static create({ loader, logger, manifest, settings, }: Pick<DevPipeline, 'loader' | 'logger' | 'manifest' | 'settings'>): DevPipeline;
+    headElements(routeData: RouteData): Promise<HeadElements>;
+    componentMetadata(routeData: RouteData): Promise<Map<string, import("../@types/astro.js").SSRComponentMetadata>>;
+    preload(filePath: URL): Promise<ComponentInstance>;
+    clearRouteCache(): void;
+}

package/dist/vite-plugin-astro-server/pipeline.js

@@ -0,0 +1,117 @@
+import url from "node:url";
+import { Pipeline, loadRenderer } from "../core/render/index.js";
+import { isPage, resolveIdToUrl, viteID } from "../core/util.js";
+import { isServerLikeOutput } from "../prerender/utils.js";
+import { createResolve } from "./resolve.js";
+import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
+import { enhanceViteSSRError } from "../core/errors/dev/index.js";
+import { getScriptsForURL } from "./scripts.js";
+import { ASTRO_VERSION } from "../core/constants.js";
+import { getInfoOutput } from "../cli/info/index.js";
+import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
+import { getStylesForURL } from "./css.js";
+import { getComponentMetadata } from "./metadata.js";
+class DevPipeline extends Pipeline {
+  constructor(loader, logger, manifest, settings, config = settings.config) {
+    const mode = "development";
+    const resolve = createResolve(loader, config.root);
+    const serverLike = isServerLikeOutput(config);
+    const streaming = true;
+    super(logger, manifest, mode, [], resolve, serverLike, streaming);
+    this.loader = loader;
+    this.logger = logger;
+    this.manifest = manifest;
+    this.settings = settings;
+    this.config = config;
+  }
+  // renderers are loaded on every request,
+  // so it needs to be mutable here unlike in other environments
+  renderers = new Array();
+  static create({
+    loader,
+    logger,
+    manifest,
+    settings
+  }) {
+    return new DevPipeline(loader, logger, manifest, settings);
+  }
+  async headElements(routeData) {
+    const {
+      config: { root },
+      loader,
+      mode,
+      settings
+    } = this;
+    const filePath = new URL(`./${routeData.component}`, root);
+    const { scripts } = await getScriptsForURL(filePath, root, loader);
+    if (isPage(filePath, settings) && mode === "development") {
+      scripts.add({
+        props: { type: "module", src: "/@vite/client" },
+        children: ""
+      });
+      if (settings.config.devToolbar.enabled && await settings.preferences.get("devToolbar.enabled")) {
+        const src = await resolveIdToUrl(loader, "astro/runtime/client/dev-toolbar/entrypoint.js");
+        scripts.add({ props: { type: "module", src }, children: "" });
+        const additionalMetadata = {
+          root: url.fileURLToPath(settings.config.root),
+          version: ASTRO_VERSION,
+          debugInfo: await getInfoOutput({ userConfig: settings.config, print: false })
+        };
+        const children = `window.__astro_dev_toolbar__ = ${JSON.stringify(additionalMetadata)}`;
+        scripts.add({ props: {}, children });
+      }
+    }
+    for (const script of settings.scripts) {
+      if (script.stage === "head-inline") {
+        scripts.add({
+          props: {},
+          children: script.content
+        });
+      } else if (script.stage === "page" && isPage(filePath, settings)) {
+        scripts.add({
+          props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
+          children: ""
+        });
+      }
+    }
+    const links = /* @__PURE__ */ new Set();
+    const { urls, styles: _styles } = await getStylesForURL(filePath, loader);
+    for (const href of urls) {
+      links.add({ props: { rel: "stylesheet", href }, children: "" });
+    }
+    const styles = /* @__PURE__ */ new Set();
+    for (const { id, url: src, content } of _styles) {
+      scripts.add({ props: { type: "module", src }, children: "" });
+      styles.add({ props: { "data-vite-dev-id": id }, children: content });
+    }
+    return { scripts, styles, links };
+  }
+  componentMetadata(routeData) {
+    const {
+      config: { root },
+      loader
+    } = this;
+    const filePath = new URL(`./${routeData.component}`, root);
+    return getComponentMetadata(filePath, loader);
+  }
+  async preload(filePath) {
+    const { loader } = this;
+    const renderers__ = this.settings.renderers.map((r) => loadRenderer(r, loader));
+    const renderers_ = await Promise.all(renderers__);
+    this.renderers = renderers_.filter((r) => Boolean(r));
+    try {
+      return await loader.import(viteID(filePath));
+    } catch (error) {
+      if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
+        throw error;
+      }
+      throw enhanceViteSSRError({ error, filePath, loader });
+    }
+  }
+  clearRouteCache() {
+    this.routeCache.clearAll();
+  }
+}
+export {
+  DevPipeline
+};

package/dist/vite-plugin-astro-server/plugin.js

@@ -3,7 +3,7 @@ import { createViteLoader } from "../core/module-loader/index.js";
 import { createRouteManifest } from "../core/routing/index.js";
 import { baseMiddleware } from "./base.js";
 import { createController } from "./controller.js";
-import DevPipeline from "./devPipeline.js";
+import { DevPipeline } from "./pipeline.js";
 import { handleRequest } from "./request.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { getViteErrorPayload } from "../core/errors/dev/index.js";
@@ -21,7 +21,7 @@ function createVitePluginAstroServer({
     configureServer(viteServer) {
       const loader = createViteLoader(viteServer);
       const manifest = createDevelopmentManifest(settings);
-      const pipeline = new DevPipeline({ logger, manifest, settings, loader });
+      const pipeline = DevPipeline.create({ loader, logger, manifest, settings });
       let manifestData = createRouteManifest({ settings, fsMod }, logger);
       const controller = createController({ loader });
       const localStorage = new AsyncLocalStorage();
@@ -68,8 +68,7 @@ function createVitePluginAstroServer({
               manifestData,
               controller,
               incomingRequest: request,
-              incomingResponse: response,
-              manifest
+              incomingResponse: response
             });
           });
         });

package/dist/vite-plugin-astro-server/request.d.ts

@@ -1,16 +1,15 @@
 /// <reference types="node" resolution-mode="require"/>
 import type http from 'node:http';
-import type { ManifestData, SSRManifest } from '../@types/astro.js';
+import type { ManifestData } from '../@types/astro.js';
 import type { DevServerController } from './controller.js';
-import type DevPipeline from './devPipeline.js';
+import type { DevPipeline } from './pipeline.js';
 type HandleRequest = {
     pipeline: DevPipeline;
     manifestData: ManifestData;
     controller: DevServerController;
     incomingRequest: http.IncomingMessage;
     incomingResponse: http.ServerResponse;
-    manifest: SSRManifest;
 };
 /** The main logic to route dev server requests to pages in Astro. */
-export declare function handleRequest({ pipeline, manifestData, controller, incomingRequest, incomingResponse, manifest, }: HandleRequest): Promise<void>;
+export declare function handleRequest({ pipeline, manifestData, controller, incomingRequest, incomingResponse, }: HandleRequest): Promise<void>;
 export {};

package/dist/vite-plugin-astro-server/request.js

@@ -9,12 +9,10 @@ async function handleRequest({
   manifestData,
   controller,
   incomingRequest,
-  incomingResponse,
-  manifest
+  incomingResponse
 }) {
-  const config = pipeline.getConfig();
-  const moduleLoader = pipeline.getModuleLoader();
-  const origin = `${moduleLoader.isHttps() ? "https" : "http"}://${incomingRequest.headers.host}`;
+  const { config, loader } = pipeline;
+  const origin = `${loader.isHttps() ? "https" : "http"}://${incomingRequest.headers.host}`;
   const buildingToSSR = isServerLikeOutput(config);
   const url = new URL(collapseDuplicateSlashes(origin + incomingRequest.url));
   let pathname;
@@ -56,13 +54,12 @@ async function handleRequest({
         pipeline,
         manifestData,
         incomingRequest,
-        incomingResponse,
-        manifest
+        incomingResponse
       });
     },
     onError(_err) {
-      const { error, errorWithMetadata } = recordServerError(moduleLoader, config, pipeline, _err);
-      handle500Response(moduleLoader, incomingResponse, errorWithMetadata);
+      const { error, errorWithMetadata } = recordServerError(loader, config, pipeline, _err);
+      handle500Response(loader, incomingResponse, errorWithMetadata);
       return error;
     }
   });

package/dist/vite-plugin-astro-server/route.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import type http from 'node:http';
-import type { ComponentInstance, ManifestData, RouteData, SSRManifest } from '../@types/astro.js';
-import type DevPipeline from './devPipeline.js';
+import type { ComponentInstance, ManifestData, RouteData } from '../@types/astro.js';
+import type { DevPipeline } from './pipeline.js';
 type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (...args: any) => Promise<infer R> ? R : any;
 export interface MatchedRoute {
     route: RouteData;
@@ -20,9 +20,8 @@ type HandleRoute = {
     manifestData: ManifestData;
     incomingRequest: http.IncomingMessage;
     incomingResponse: http.ServerResponse;
-    manifest: SSRManifest;
     status?: 404 | 500;
     pipeline: DevPipeline;
 };
-export declare function handleRoute({ matchedRoute, url, pathname, status, body, origin, pipeline, manifestData, incomingRequest, incomingResponse, manifest, }: HandleRoute): Promise<void>;
+export declare function handleRoute({ matchedRoute, url, pathname, status, body, origin, pipeline, manifestData, incomingRequest, incomingResponse, }: HandleRoute): Promise<void>;
 export {};

package/dist/vite-plugin-astro-server/route.js

@@ -1,29 +1,15 @@
-import { fileURLToPath } from "node:url";
-import { getInfoOutput } from "../cli/info/index.js";
-import { ASTRO_VERSION } from "../core/constants.js";
 import { AstroErrorData, isAstroError } from "../core/errors/index.js";
 import { req } from "../core/messages.js";
-import { sequence } from "../core/middleware/index.js";
 import { loadMiddleware } from "../core/middleware/loadMiddleware.js";
-import {
-  createRenderContext,
-  getParamsAndProps
-} from "../core/render/index.js";
+import { getProps } from "../core/render/index.js";
 import { createRequest } from "../core/request.js";
 import { matchAllRoutes } from "../core/routing/index.js";
-import { isPage, resolveIdToUrl } from "../core/util.js";
 import { normalizeTheLocale } from "../i18n/index.js";
-import { createI18nMiddleware, i18nPipelineHook } from "../i18n/middleware.js";
 import { getSortedPreloadedMatches } from "../prerender/routing.js";
 import { isServerLikeOutput } from "../prerender/utils.js";
-import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
-import { getStylesForURL } from "./css.js";
-import { preload } from "./index.js";
-import { getComponentMetadata } from "./metadata.js";
 import { handle404Response, writeSSRResult, writeWebResponse } from "./response.js";
-import { getScriptsForURL } from "./scripts.js";
-import { REROUTE_DIRECTIVE_HEADER } from "../runtime/server/consts.js";
-const clientLocalsSymbol = Symbol.for("astro.locals");
+import { REROUTE_DIRECTIVE_HEADER, clientLocalsSymbol } from "../core/constants.js";
+import { RenderContext } from "../core/render-context.js";
 function isLoggedRequest(url) {
   return url !== "/favicon.ico";
 }
@@ -32,23 +18,18 @@ function getCustom404Route(manifestData) {
   return manifestData.routes.find((r) => route404.test(r.route));
 }
 async function matchRoute(pathname, manifestData, pipeline) {
-  const env = pipeline.getEnvironment();
-  const { routeCache, logger } = env;
-  let matches = matchAllRoutes(pathname, manifestData);
-  const preloadedMatches = await getSortedPreloadedMatches({
-    pipeline,
-    matches,
-    settings: pipeline.getSettings()
-  });
+  const { config, logger, routeCache, serverLike, settings } = pipeline;
+  const matches = matchAllRoutes(pathname, manifestData);
+  const preloadedMatches = await getSortedPreloadedMatches({ pipeline, matches, settings });
   for await (const { preloadedComponent, route: maybeRoute, filePath } of preloadedMatches) {
     try {
-      await getParamsAndProps({
+      await getProps({
         mod: preloadedComponent,
-        route: maybeRoute,
+        routeData: maybeRoute,
         routeCache,
         pathname,
         logger,
-        ssr: isServerLikeOutput(pipeline.getConfig())
+        serverLike
       });
       return {
         route: maybeRoute,
@@ -70,7 +51,7 @@ async function matchRoute(pathname, manifestData, pipeline) {
   }
   if (matches.length) {
     const possibleRoutes = matches.flatMap((route) => route.component);
-    pipeline.logger.warn(
+    logger.warn(
       "router",
       `${AstroErrorData.NoMatchingStaticPathFound.message(
         pathname
@@ -81,8 +62,8 @@ ${AstroErrorData.NoMatchingStaticPathFound.hint(possibleRoutes)}`
   }
   const custom404 = getCustom404Route(manifestData);
   if (custom404) {
-    const filePath = new URL(`./${custom404.component}`, pipeline.getConfig().root);
-    const preloadedComponent = await preload({ pipeline, filePath });
+    const filePath = new URL(`./${custom404.component}`, config.root);
+    const preloadedComponent = await pipeline.preload(filePath);
     return {
       route: custom404,
       filePath,
@@ -103,14 +84,10 @@ async function handleRoute({
   pipeline,
   manifestData,
   incomingRequest,
-  incomingResponse,
-  manifest
+  incomingResponse
 }) {
   const timeStart = performance.now();
-  const env = pipeline.getEnvironment();
-  const config = pipeline.getConfig();
-  const moduleLoader = pipeline.getModuleLoader();
-  const { logger } = env;
+  const { config, loader, logger } = pipeline;
   if (!matchedRoute && !config.i18n) {
     if (isLoggedRequest(pathname)) {
       logger.info(null, req({ url: pathname, method: incomingRequest.method, statusCode: 404 }));
@@ -123,7 +100,7 @@ async function handleRoute({
   let mod = void 0;
   let options = void 0;
   let route;
-  const middleware = await loadMiddleware(moduleLoader);
+  const middleware = (await loadMiddleware(loader)).onRequest;
   if (!matchedRoute) {
     if (config.i18n) {
       const locales = config.i18n.locales;
@@ -169,15 +146,12 @@ async function handleRoute({
         fallbackRoutes: [],
         isIndex: false
       };
-      renderContext = await createRenderContext({
-        request,
+      renderContext = RenderContext.create({
+        pipeline,
         pathname,
-        env,
-        mod,
-        route,
-        locales: manifest.i18n?.locales,
-        routing: manifest.i18n?.routing,
-        defaultLocale: manifest.i18n?.defaultLocale
+        middleware,
+        request,
+        routeData: route
       });
     } else {
       return handle404Response(origin, incomingRequest, incomingResponse);
@@ -186,69 +160,40 @@ async function handleRoute({
     const filePath = matchedRoute.filePath;
     const { preloadedComponent } = matchedRoute;
     route = matchedRoute.route;
+    const locals = Reflect.get(incomingRequest, clientLocalsSymbol);
     request = createRequest({
       url,
+      // Headers are only available when using SSR.
       headers: buildingToSSR ? incomingRequest.headers : new Headers(),
       method: incomingRequest.method,
       body,
       logger,
       ssr: buildingToSSR,
-      clientAddress: buildingToSSR ? incomingRequest.socket.remoteAddress : void 0,
-      locals: Reflect.get(incomingRequest, clientLocalsSymbol)
-      // Allows adapters to pass in locals in dev mode.
+      clientAddress: buildingToSSR ? incomingRequest.socket.remoteAddress : void 0
     });
     for (const [name, value] of Object.entries(config.server.headers ?? {})) {
       if (value)
         incomingResponse.setHeader(name, value);
     }
     options = {
-      env,
+      pipeline,
       filePath,
       preload: preloadedComponent,
       pathname,
       request,
-      route,
-      middleware
+      route
     };
-    mod = options.preload;
-    const { scripts, links, styles, metadata } = await getScriptsAndStyles({
+    mod = preloadedComponent;
+    renderContext = RenderContext.create({
+      locals,
       pipeline,
-      filePath: options.filePath
-    });
-    const i18n = pipeline.getConfig().i18n;
-    renderContext = await createRenderContext({
-      request: options.request,
-      pathname: options.pathname,
-      scripts,
-      links,
-      styles,
-      componentMetadata: metadata,
-      route: options.route,
-      mod,
-      env,
-      locales: i18n?.locales,
-      routing: i18n?.routing,
-      defaultLocale: i18n?.defaultLocale
+      pathname,
+      middleware,
+      request,
+      routeData: route
     });
   }
-  const onRequest = middleware.onRequest;
-  if (config.i18n) {
-    const i18Middleware = createI18nMiddleware(
-      manifest.i18n,
-      config.base,
-      config.trailingSlash,
-      config.build.format
-    );
-    if (i18Middleware) {
-      pipeline.setMiddlewareFunction(sequence(i18Middleware, onRequest));
-      pipeline.onBeforeRenderRoute(i18nPipelineHook);
-    } else {
-      pipeline.setMiddlewareFunction(onRequest);
-    }
-  } else {
-    pipeline.setMiddlewareFunction(onRequest);
-  }
-  let response = await pipeline.renderRoute(renderContext, mod);
+  let response = await renderContext.render(mod);
   if (isLoggedRequest(pathname)) {
     const timeEnd = performance.now();
     logger.info(
@@ -274,8 +219,7 @@ async function handleRoute({
         pipeline,
         manifestData,
         incomingRequest,
-        incomingResponse,
-        manifest
+        incomingResponse
       });
   }
   if (route.type === "endpoint") {
@@ -294,78 +238,6 @@ async function handleRoute({
   }
   await writeSSRResult(request, response, incomingResponse);
 }
-async function getScriptsAndStyles({ pipeline, filePath }) {
-  const moduleLoader = pipeline.getModuleLoader();
-  const settings = pipeline.getSettings();
-  const mode = pipeline.getEnvironment().mode;
-  const { scripts } = await getScriptsForURL(filePath, settings.config.root, moduleLoader);
-  if (isPage(filePath, settings) && mode === "development") {
-    scripts.add({
-      props: { type: "module", src: "/@vite/client" },
-      children: ""
-    });
-    if (settings.config.devToolbar.enabled && await settings.preferences.get("devToolbar.enabled")) {
-      scripts.add({
-        props: {
-          type: "module",
-          src: await resolveIdToUrl(moduleLoader, "astro/runtime/client/dev-toolbar/entrypoint.js")
-        },
-        children: ""
-      });
-      const additionalMetadata = {
-        root: fileURLToPath(settings.config.root),
-        version: ASTRO_VERSION,
-        debugInfo: await getInfoOutput({ userConfig: settings.config, print: false })
-      };
-      scripts.add({
-        props: {},
-        children: `window.__astro_dev_toolbar__ = ${JSON.stringify(additionalMetadata)}`
-      });
-    }
-  }
-  for (const script of settings.scripts) {
-    if (script.stage === "head-inline") {
-      scripts.add({
-        props: {},
-        children: script.content
-      });
-    } else if (script.stage === "page" && isPage(filePath, settings)) {
-      scripts.add({
-        props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
-        children: ""
-      });
-    }
-  }
-  const { urls: styleUrls, styles: importedStyles } = await getStylesForURL(filePath, moduleLoader);
-  let links = /* @__PURE__ */ new Set();
-  [...styleUrls].forEach((href) => {
-    links.add({
-      props: {
-        rel: "stylesheet",
-        href
-      },
-      children: ""
-    });
-  });
-  let styles = /* @__PURE__ */ new Set();
-  importedStyles.forEach(({ id, url, content }) => {
-    scripts.add({
-      props: {
-        type: "module",
-        src: url
-      },
-      children: ""
-    });
-    styles.add({
-      props: {
-        "data-vite-dev-id": id
-      },
-      children: content
-    });
-  });
-  const metadata = await getComponentMetadata(filePath, moduleLoader);
-  return { scripts, styles, links, metadata };
-}
 function getStatus(matchedRoute) {
   if (!matchedRoute)
     return 404;

package/dist/vite-plugin-dev-toolbar/vite-plugin-dev-toolbar.js

@@ -20,20 +20,20 @@ function astroDevToolbar({ settings, logger }) {
       }
     },
     configureServer(server) {
-      server.ws.on("astro:devtoolbar:error:load", (args) => {
+      server.hot.on("astro:devtoolbar:error:load", (args) => {
         logger.error(
           "toolbar",
           `Failed to load dev toolbar app from ${args.entrypoint}: ${args.error}`
         );
       });
-      server.ws.on("astro:devtoolbar:error:init", (args) => {
+      server.hot.on("astro:devtoolbar:error:init", (args) => {
         logger.error(
           "toolbar",
           `Failed to initialize dev toolbar app ${args.app.name} (${args.app.id}):
 ${args.error}`
         );
       });
-      server.ws.on("astro:devtoolbar:app:toggled", (args) => {
+      server.hot.on("astro:devtoolbar:app:toggled", (args) => {
         clearTimeout(telemetryTimeout);
         telemetryTimeout = setTimeout(() => {
           let nameToRecord = args?.app?.id;