blank project

node_modules/astro/dist/vite-plugin-astro-server/base.d.ts

@@ -0,0 +1,4 @@
+import type * as vite from 'vite';
+import type { Logger } from '../core/logger/core.js';
+import type { AstroSettings } from '../types/astro.js';
+export declare function baseMiddleware(settings: AstroSettings, logger: Logger): vite.Connect.NextHandleFunction;

node_modules/astro/dist/vite-plugin-astro-server/base.js

@@ -0,0 +1,56 @@
+import * as fs from "node:fs";
+import path from "node:path";
+import { appendForwardSlash } from "@astrojs/internal-helpers/path";
+import { bold } from "kleur/colors";
+import { notFoundTemplate, subpathNotUsedTemplate } from "../template/4xx.js";
+import { writeHtmlResponse } from "./response.js";
+function baseMiddleware(settings, logger) {
+  const { config } = settings;
+  const site = config.site ? new URL(config.base, config.site) : void 0;
+  const devRootURL = new URL(config.base, "http://localhost");
+  const devRoot = site ? site.pathname : devRootURL.pathname;
+  const devRootReplacement = devRoot.endsWith("/") ? "/" : "";
+  return function devBaseMiddleware(req, res, next) {
+    const url = req.url;
+    let pathname;
+    try {
+      pathname = decodeURI(new URL(url, "http://localhost").pathname);
+    } catch (e) {
+      return next(e);
+    }
+    if (pathname.startsWith(devRoot)) {
+      req.url = url.replace(devRoot, devRootReplacement);
+      return next();
+    }
+    if (pathname === "/" || pathname === "/index.html") {
+      const html = subpathNotUsedTemplate(devRoot, pathname);
+      return writeHtmlResponse(res, 404, html);
+    }
+    if (req.headers.accept?.includes("text/html")) {
+      const html = notFoundTemplate(pathname);
+      return writeHtmlResponse(res, 404, html);
+    }
+    const publicPath = new URL("." + req.url, config.publicDir);
+    fs.stat(publicPath, (_err, stats) => {
+      if (stats) {
+        const publicDir = appendForwardSlash(
+          path.posix.relative(config.root.pathname, config.publicDir.pathname)
+        );
+        const expectedLocation = new URL(devRootURL.pathname + url, devRootURL).pathname;
+        logger.error(
+          "router",
+          `Request URLs for ${bold(
+            publicDir
+          )} assets must also include your base. "${expectedLocation}" expected, but received "${url}".`
+        );
+        const html = subpathNotUsedTemplate(devRoot, pathname);
+        return writeHtmlResponse(res, 404, html);
+      } else {
+        next();
+      }
+    });
+  };
+}
+export {
+  baseMiddleware
+};

node_modules/astro/dist/vite-plugin-astro-server/controller.d.ts

@@ -0,0 +1,22 @@
+import type { LoaderEvents, ModuleLoader } from '../core/module-loader/index.js';
+import type { ServerState } from './server-state.js';
+type ReloadFn = () => void;
+export interface DevServerController {
+    state: ServerState;
+    onFileChange: LoaderEvents['file-change'];
+    onHMRError: LoaderEvents['hmr-error'];
+}
+type CreateControllerParams = {
+    loader: ModuleLoader;
+} | {
+    reload: ReloadFn;
+};
+export declare function createController(params: CreateControllerParams): DevServerController;
+interface RunWithErrorHandlingParams {
+    controller: DevServerController;
+    pathname: string;
+    run: () => Promise<any>;
+    onError: (error: unknown) => Error;
+}
+export declare function runWithErrorHandling({ controller: { state }, pathname, run, onError, }: RunWithErrorHandlingParams): Promise<void>;
+export {};

node_modules/astro/dist/vite-plugin-astro-server/controller.js

@@ -0,0 +1,74 @@
+import {
+  clearRouteError,
+  createServerState,
+  setRouteError,
+  setServerError
+} from "./server-state.js";
+function createController(params) {
+  if ("loader" in params) {
+    return createLoaderController(params.loader);
+  } else {
+    return createBaseController(params);
+  }
+}
+function createBaseController({ reload }) {
+  const serverState = createServerState();
+  const onFileChange = () => {
+    if (serverState.state === "error") {
+      reload();
+    }
+  };
+  const onHMRError = (payload) => {
+    let msg = payload?.err?.message ?? "Unknown error";
+    let stack = payload?.err?.stack ?? "Unknown stack";
+    let error = new Error(msg);
+    Object.defineProperty(error, "stack", {
+      value: stack
+    });
+    setServerError(serverState, error);
+  };
+  return {
+    state: serverState,
+    onFileChange,
+    onHMRError
+  };
+}
+function createLoaderController(loader) {
+  const controller = createBaseController({
+    reload() {
+      loader.clientReload();
+    }
+  });
+  const baseOnFileChange = controller.onFileChange;
+  controller.onFileChange = (...args) => {
+    if (controller.state.state === "error") {
+      loader.eachModule((mod) => {
+        if (mod.ssrError) {
+          loader.invalidateModule(mod);
+        }
+      });
+    }
+    baseOnFileChange(...args);
+  };
+  loader.events.on("file-change", controller.onFileChange);
+  loader.events.on("hmr-error", controller.onHMRError);
+  return controller;
+}
+async function runWithErrorHandling({
+  controller: { state },
+  pathname,
+  run,
+  onError
+}) {
+  try {
+    await run();
+    clearRouteError(state, pathname);
+  } catch (err) {
+    const error = onError(err);
+    setRouteError(state, pathname, error);
+  }
+}
+export {
+  createController,
+  runWithErrorHandling
+};

node_modules/astro/dist/vite-plugin-astro-server/css.d.ts

@@ -0,0 +1,13 @@
+import type { ModuleLoader } from '../core/module-loader/index.js';
+interface ImportedStyle {
+    id: string;
+    url: string;
+    content: string;
+}
+/** Given a filePath URL, crawl Vite’s module graph to find all style imports. */
+export declare function getStylesForURL(filePath: URL, loader: ModuleLoader): Promise<{
+    urls: Set<string>;
+    styles: ImportedStyle[];
+    crawledFiles: Set<string>;
+}>;
+export {};

node_modules/astro/dist/vite-plugin-astro-server/css.js

@@ -0,0 +1,48 @@
+import { viteID, wrapId } from "../core/util.js";
+import { isBuildableCSSRequest } from "./util.js";
+import { crawlGraph } from "./vite.js";
+const inlineQueryRE = /(?:\?|&)inline(?:$|&)/;
+async function getStylesForURL(filePath, loader) {
+  const importedCssUrls = /* @__PURE__ */ new Set();
+  const importedStylesMap = /* @__PURE__ */ new Map();
+  const crawledFiles = /* @__PURE__ */ new Set();
+  for await (const importedModule of crawlGraph(loader, viteID(filePath), true)) {
+    if (importedModule.file) {
+      crawledFiles.add(importedModule.file);
+    }
+    if (isBuildableCSSRequest(importedModule.url)) {
+      let css = "";
+      if (typeof importedModule.ssrModule?.default === "string") {
+        css = importedModule.ssrModule.default;
+      } else {
+        let modId = importedModule.url;
+        if (!inlineQueryRE.test(importedModule.url)) {
+          if (importedModule.url.includes("?")) {
+            modId = importedModule.url.replace("?", "?inline&");
+          } else {
+            modId += "?inline";
+          }
+        }
+        try {
+          const ssrModule = await loader.import(modId);
+          css = ssrModule.default;
+        } catch {
+          continue;
+        }
+      }
+      importedStylesMap.set(importedModule.url, {
+        id: wrapId(importedModule.id ?? importedModule.url),
+        url: wrapId(importedModule.url),
+        content: css
+      });
+    }
+  }
+  return {
+    urls: importedCssUrls,
+    styles: [...importedStylesMap.values()],
+    crawledFiles
+  };
+}
+export {
+  getStylesForURL
+};

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

@@ -0,0 +1,7 @@
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { AstroConfig } from '../types/public/config.js';
+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;
+};

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

@@ -0,0 +1,19 @@
+import { collectErrorMetadata } from "../core/errors/dev/index.js";
+import { createSafeError } from "../core/errors/index.js";
+import { formatErrorMessage } from "../core/messages.js";
+function recordServerError(loader, config, { logger }, _err) {
+  const err = createSafeError(_err);
+  try {
+    loader.fixStacktrace(err);
+  } catch {
+  }
+  const errorWithMetadata = collectErrorMetadata(err, config.root);
+  logger.error(null, formatErrorMessage(errorWithMetadata, logger.level() === "debug"));
+  return {
+    error: err,
+    errorWithMetadata
+  };
+}
+export {
+  recordServerError
+};

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

@@ -0,0 +1,3 @@
+export { createController, runWithErrorHandling } from './controller.js';
+export { default as vitePluginAstroServer } from './plugin.js';
+export { handleRequest } from './request.js';

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

@@ -0,0 +1,9 @@
+import { createController, runWithErrorHandling } from "./controller.js";
+import { default as default2 } from "./plugin.js";
+import { handleRequest } from "./request.js";
+export {
+  createController,
+  handleRequest,
+  runWithErrorHandling,
+  default2 as vitePluginAstroServer
+};

node_modules/astro/dist/vite-plugin-astro-server/metadata.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { SSRResult } from '../types/public/internal.js';
+export declare function getComponentMetadata(filePath: URL, loader: ModuleLoader): Promise<SSRResult['componentMetadata']>;

node_modules/astro/dist/vite-plugin-astro-server/metadata.js

@@ -0,0 +1,36 @@
+import { viteID } from "../core/util.js";
+import { getAstroMetadata } from "../vite-plugin-astro/index.js";
+import { crawlGraph } from "./vite.js";
+async function getComponentMetadata(filePath, loader) {
+  const map = /* @__PURE__ */ new Map();
+  const rootID = viteID(filePath);
+  addMetadata(map, loader.getModuleInfo(rootID));
+  for await (const moduleNode of crawlGraph(loader, rootID, true)) {
+    const id = moduleNode.id;
+    if (id) {
+      addMetadata(map, loader.getModuleInfo(id));
+    }
+  }
+  return map;
+}
+function addMetadata(map, modInfo) {
+  if (modInfo) {
+    const astro = getAstroMetadata(modInfo);
+    if (astro) {
+      let metadata = {
+        containsHead: false,
+        propagation: "none"
+      };
+      if (astro.propagation) {
+        metadata.propagation = astro.propagation;
+      }
+      if (astro.containsHead) {
+        metadata.containsHead = astro.containsHead;
+      }
+      map.set(modInfo.id, metadata);
+    }
+  }
+}
+export {
+  getComponentMetadata
+};

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

@@ -0,0 +1,32 @@
+import type { HeadElements, TryRewriteResult } from '../core/base-pipeline.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 { AstroSettings, ComponentInstance, RoutesList } from '../types/astro.js';
+import type { RewritePayload } from '../types/public/common.js';
+import type { RouteData, SSRLoadedRenderer, SSRManifest } from '../types/public/internal.js';
+export declare class DevPipeline extends Pipeline {
+    readonly loader: ModuleLoader;
+    readonly logger: Logger;
+    readonly manifest: SSRManifest;
+    readonly settings: AstroSettings;
+    readonly config: import("../index.js").AstroConfig;
+    readonly defaultRoutes: {
+        instance: ComponentInstance;
+        matchesComponent(filePath: URL): boolean;
+        route: string;
+        component: string;
+    }[];
+    renderers: SSRLoadedRenderer[];
+    routesList: RoutesList | undefined;
+    componentInterner: WeakMap<RouteData, ComponentInstance>;
+    private constructor();
+    static create(manifestData: RoutesList, { loader, logger, manifest, settings, }: Pick<DevPipeline, 'loader' | 'logger' | 'manifest' | 'settings'>): DevPipeline;
+    headElements(routeData: RouteData): Promise<HeadElements>;
+    componentMetadata(routeData: RouteData): Promise<Map<string, import("../types/public/internal.js").SSRComponentMetadata>>;
+    preload(routeData: RouteData, filePath: URL): Promise<ComponentInstance>;
+    clearRouteCache(): void;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
+    setManifestData(manifestData: RoutesList): void;
+}

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

@@ -0,0 +1,161 @@
+import { fileURLToPath } from "node:url";
+import { getInfoOutput } from "../cli/info/index.js";
+import { ASTRO_VERSION } from "../core/constants.js";
+import { enhanceViteSSRError } from "../core/errors/dev/index.js";
+import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
+import { loadRenderer, Pipeline } from "../core/render/index.js";
+import { createDefaultRoutes } from "../core/routing/default.js";
+import { findRouteToRewrite } from "../core/routing/rewrite.js";
+import { isPage, viteID } from "../core/util.js";
+import { resolveIdToUrl } from "../core/viteUtils.js";
+import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
+import { getStylesForURL } from "./css.js";
+import { getComponentMetadata } from "./metadata.js";
+import { createResolve } from "./resolve.js";
+class DevPipeline extends Pipeline {
+  constructor(loader, logger, manifest, settings, config = settings.config, defaultRoutes = createDefaultRoutes(manifest)) {
+    const resolve = createResolve(loader, config.root);
+    const serverLike = settings.buildOutput === "server";
+    const streaming = true;
+    super(logger, manifest, "development", [], resolve, serverLike, streaming);
+    this.loader = loader;
+    this.logger = logger;
+    this.manifest = manifest;
+    this.settings = settings;
+    this.config = config;
+    this.defaultRoutes = defaultRoutes;
+    manifest.serverIslandMap = settings.serverIslandMap;
+    manifest.serverIslandNameMap = settings.serverIslandNameMap;
+  }
+  // renderers are loaded on every request,
+  // so it needs to be mutable here unlike in other environments
+  renderers = new Array();
+  routesList;
+  componentInterner = /* @__PURE__ */ new WeakMap();
+  static create(manifestData, {
+    loader,
+    logger,
+    manifest,
+    settings
+  }) {
+    const pipeline = new DevPipeline(loader, logger, manifest, settings);
+    pipeline.routesList = manifestData;
+    return pipeline;
+  }
+  async headElements(routeData) {
+    const {
+      config: { root },
+      loader,
+      runtimeMode,
+      settings
+    } = this;
+    const filePath = new URL(`${routeData.component}`, root);
+    const scripts = /* @__PURE__ */ new Set();
+    if (isPage(filePath, settings) && runtimeMode === "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: fileURLToPath(settings.config.root),
+          version: ASTRO_VERSION,
+          latestAstroVersion: settings.latestAstroVersion,
+          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(routeData, filePath) {
+    const { loader } = this;
+    for (const route of this.defaultRoutes) {
+      if (route.matchesComponent(filePath)) {
+        return route.instance;
+      }
+    }
+    const renderers__ = this.settings.renderers.map((r) => loadRenderer(r, loader));
+    const renderers_ = await Promise.all(renderers__);
+    this.renderers = renderers_.filter((r) => Boolean(r));
+    try {
+      const componentInstance = await loader.import(viteID(filePath));
+      this.componentInterner.set(routeData, componentInstance);
+      return componentInstance;
+    } catch (error) {
+      if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
+        throw error;
+      }
+      throw enhanceViteSSRError({ error, filePath, loader });
+    }
+  }
+  clearRouteCache() {
+    this.routeCache.clearAll();
+    this.componentInterner = /* @__PURE__ */ new WeakMap();
+  }
+  async getComponentByRoute(routeData) {
+    const component = this.componentInterner.get(routeData);
+    if (component) {
+      return component;
+    } else {
+      const filePath = new URL(`${routeData.component}`, this.config.root);
+      return await this.preload(routeData, filePath);
+    }
+  }
+  async tryRewrite(payload, request) {
+    if (!this.routesList) {
+      throw new Error("Missing manifest data. This is an internal error, please file an issue.");
+    }
+    const { routeData, pathname, newUrl } = findRouteToRewrite({
+      payload,
+      request,
+      routes: this.routesList?.routes,
+      trailingSlash: this.config.trailingSlash,
+      buildFormat: this.config.build.format,
+      base: this.config.base,
+      outDir: this.manifest.outDir
+    });
+    const componentInstance = await this.getComponentByRoute(routeData);
+    return { newUrl, pathname, componentInstance, routeData };
+  }
+  setManifestData(manifestData) {
+    this.routesList = manifestData;
+  }
+}
+export {
+  DevPipeline
+};

node_modules/astro/dist/vite-plugin-astro-server/plugin.d.ts

@@ -0,0 +1,21 @@
+import type fs from 'node:fs';
+import type * as vite from 'vite';
+import type { SSRManifest } from '../core/app/types.js';
+import type { Logger } from '../core/logger/core.js';
+import type { AstroSettings, RoutesList } from '../types/astro.js';
+interface AstroPluginOptions {
+    settings: AstroSettings;
+    logger: Logger;
+    fs: typeof fs;
+    routesList: RoutesList;
+    manifest: SSRManifest;
+}
+export default function createVitePluginAstroServer({ settings, logger, fs: fsMod, routesList, manifest, }: AstroPluginOptions): vite.Plugin;
+/**
+ * It creates a `SSRManifest` from the `AstroSettings`.
+ *
+ * Renderers needs to be pulled out from the page module emitted during the build.
+ * @param settings
+ */
+export declare function createDevelopmentManifest(settings: AstroSettings): SSRManifest;
+export {};

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

@@ -0,0 +1,235 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { IncomingMessage } from "node:http";
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "vite";
+import {
+  getAlgorithm,
+  getDirectives,
+  getScriptHashes,
+  getScriptResources,
+  getStrictDynamic,
+  getStyleHashes,
+  getStyleResources,
+  shouldTrackCspHashes
+} from "../core/csp/common.js";
+import { warnMissingAdapter } from "../core/dev/adapter-validation.js";
+import { createKey, getEnvironmentKey, hasEnvironmentKey } from "../core/encryption.js";
+import { getViteErrorPayload } from "../core/errors/dev/index.js";
+import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { patchOverlay } from "../core/errors/overlay.js";
+import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
+import { createViteLoader } from "../core/module-loader/index.js";
+import { createRoutesList } from "../core/routing/index.js";
+import { getRoutePrerenderOption } from "../core/routing/manifest/prerender.js";
+import { toFallbackType, toRoutingStrategy } from "../i18n/utils.js";
+import { runHookRoutesResolved } from "../integrations/hooks.js";
+import { baseMiddleware } from "./base.js";
+import { createController } from "./controller.js";
+import { recordServerError } from "./error.js";
+import { DevPipeline } from "./pipeline.js";
+import { handleRequest } from "./request.js";
+import { setRouteError } from "./server-state.js";
+import { trailingSlashMiddleware } from "./trailing-slash.js";
+function createVitePluginAstroServer({
+  settings,
+  logger,
+  fs: fsMod,
+  routesList,
+  manifest
+}) {
+  return {
+    name: "astro:server",
+    async configureServer(viteServer) {
+      const loader = createViteLoader(viteServer);
+      const pipeline = DevPipeline.create(routesList, {
+        loader,
+        logger,
+        manifest,
+        settings
+      });
+      const controller = createController({ loader });
+      const localStorage = new AsyncLocalStorage();
+      async function rebuildManifest(path = null) {
+        pipeline.clearRouteCache();
+        if (path !== null) {
+          const route = routesList.routes.find(
+            (r) => normalizePath(path) === normalizePath(fileURLToPath(new URL(r.component, settings.config.root)))
+          );
+          if (!route) {
+            return;
+          }
+          if (route.type !== "page" && route.type !== "endpoint") return;
+          const routePath = fileURLToPath(new URL(route.component, settings.config.root));
+          try {
+            const content = await fsMod.promises.readFile(routePath, "utf-8");
+            await getRoutePrerenderOption(content, route, settings, logger);
+            await runHookRoutesResolved({ routes: routesList.routes, settings, logger });
+          } catch (_) {
+          }
+        } else {
+          routesList = await createRoutesList({ settings, fsMod }, logger, { dev: true });
+        }
+        warnMissingAdapter(logger, settings);
+        pipeline.manifest.checkOrigin = settings.config.security.checkOrigin && settings.buildOutput === "server";
+        pipeline.setManifestData(routesList);
+      }
+      viteServer.watcher.on("add", rebuildManifest.bind(null, null));
+      viteServer.watcher.on("unlink", rebuildManifest.bind(null, null));
+      viteServer.watcher.on("change", rebuildManifest);
+      function handleUnhandledRejection(rejection) {
+        const error = AstroError.is(rejection) ? rejection : new AstroError({
+          ...AstroErrorData.UnhandledRejection,
+          message: AstroErrorData.UnhandledRejection.message(rejection?.stack || rejection)
+        });
+        const store = localStorage.getStore();
+        if (store instanceof IncomingMessage) {
+          setRouteError(controller.state, store.url, error);
+        }
+        const { errorWithMetadata } = recordServerError(loader, settings.config, pipeline, error);
+        setTimeout(
+          async () => loader.webSocketSend(await getViteErrorPayload(errorWithMetadata)),
+          200
+        );
+      }
+      process.on("unhandledRejection", handleUnhandledRejection);
+      viteServer.httpServer?.on("close", () => {
+        process.off("unhandledRejection", handleUnhandledRejection);
+      });
+      return () => {
+        viteServer.middlewares.stack.unshift({
+          route: "",
+          handle: baseMiddleware(settings, logger)
+        });
+        viteServer.middlewares.stack.unshift({
+          route: "",
+          handle: trailingSlashMiddleware(settings)
+        });
+        viteServer.middlewares.use(async function chromeDevToolsHandler(request, response, next) {
+          if (request.url !== "/.well-known/appspecific/com.chrome.devtools.json") {
+            return next();
+          }
+          if (!settings.config.experimental.chromeDevtoolsWorkspace) {
+            response.writeHead(404);
+            response.end();
+            return;
+          }
+          const pluginVersion = "1.1";
+          const cacheDir = settings.config.cacheDir;
+          const configPath = new URL("./chrome-workspace.json", cacheDir);
+          if (!existsSync(cacheDir)) {
+            await mkdir(cacheDir, { recursive: true });
+          }
+          let config;
+          try {
+            config = JSON.parse(await readFile(configPath, "utf-8"));
+            if (config.version !== pluginVersion) throw new Error("Cached config is outdated.");
+          } catch {
+            config = {
+              workspace: {
+                version: pluginVersion,
+                uuid: randomUUID(),
+                root: fileURLToPath(settings.config.root)
+              }
+            };
+            await writeFile(configPath, JSON.stringify(config));
+          }
+          response.setHeader("Content-Type", "application/json");
+          response.end(JSON.stringify(config));
+          return;
+        });
+        viteServer.middlewares.use(async function astroDevHandler(request, response) {
+          if (request.url === void 0 || !request.method) {
+            response.writeHead(500, "Incomplete request");
+            response.end();
+            return;
+          }
+          localStorage.run(request, () => {
+            handleRequest({
+              pipeline,
+              routesList,
+              controller,
+              incomingRequest: request,
+              incomingResponse: response
+            });
+          });
+        });
+      };
+    },
+    transform(code, id, opts = {}) {
+      if (opts.ssr) return;
+      if (!id.includes("vite/dist/client/client.mjs")) return;
+      return patchOverlay(code);
+    }
+  };
+}
+function createDevelopmentManifest(settings) {
+  let i18nManifest;
+  let csp;
+  if (settings.config.i18n) {
+    i18nManifest = {
+      fallback: settings.config.i18n.fallback,
+      strategy: toRoutingStrategy(settings.config.i18n.routing, settings.config.i18n.domains),
+      defaultLocale: settings.config.i18n.defaultLocale,
+      locales: settings.config.i18n.locales,
+      domainLookupTable: {},
+      fallbackType: toFallbackType(settings.config.i18n.routing)
+    };
+  }
+  if (shouldTrackCspHashes(settings.config.experimental.csp)) {
+    const styleHashes = [
+      ...getStyleHashes(settings.config.experimental.csp),
+      ...settings.injectedCsp.styleHashes
+    ];
+    csp = {
+      cspDestination: settings.adapter?.adapterFeatures?.experimentalStaticHeaders ? "adapter" : void 0,
+      scriptHashes: getScriptHashes(settings.config.experimental.csp),
+      scriptResources: getScriptResources(settings.config.experimental.csp),
+      styleHashes,
+      styleResources: getStyleResources(settings.config.experimental.csp),
+      algorithm: getAlgorithm(settings.config.experimental.csp),
+      directives: getDirectives(settings),
+      isStrictDynamic: getStrictDynamic(settings.config.experimental.csp)
+    };
+  }
+  return {
+    hrefRoot: settings.config.root.toString(),
+    srcDir: settings.config.srcDir,
+    cacheDir: settings.config.cacheDir,
+    outDir: settings.config.outDir,
+    buildServerDir: settings.config.build.server,
+    buildClientDir: settings.config.build.client,
+    publicDir: settings.config.publicDir,
+    trailingSlash: settings.config.trailingSlash,
+    buildFormat: settings.config.build.format,
+    compressHTML: settings.config.compressHTML,
+    assets: /* @__PURE__ */ new Set(),
+    entryModules: {},
+    routes: [],
+    adapterName: settings?.adapter?.name ?? "",
+    clientDirectives: settings.clientDirectives,
+    renderers: [],
+    base: settings.config.base,
+    userAssetsBase: settings.config?.vite?.base,
+    assetsPrefix: settings.config.build.assetsPrefix,
+    site: settings.config.site,
+    componentMetadata: /* @__PURE__ */ new Map(),
+    inlinedScripts: /* @__PURE__ */ new Map(),
+    i18n: i18nManifest,
+    checkOrigin: (settings.config.security?.checkOrigin && settings.buildOutput === "server") ?? false,
+    key: hasEnvironmentKey() ? getEnvironmentKey() : createKey(),
+    middleware() {
+      return {
+        onRequest: NOOP_MIDDLEWARE_FN
+      };
+    },
+    sessionConfig: settings.config.session,
+    csp
+  };
+}
+export {
+  createDevelopmentManifest,
+  createVitePluginAstroServer as default
+};

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

@@ -0,0 +1,14 @@
+import type http from 'node:http';
+import type { RoutesList } from '../types/astro.js';
+import type { DevServerController } from './controller.js';
+import type { DevPipeline } from './pipeline.js';
+type HandleRequest = {
+    pipeline: DevPipeline;
+    routesList: RoutesList;
+    controller: DevServerController;
+    incomingRequest: http.IncomingMessage;
+    incomingResponse: http.ServerResponse;
+};
+/** The main logic to route dev server requests to pages in Astro. */
+export declare function handleRequest({ pipeline, routesList, controller, incomingRequest, incomingResponse, }: HandleRequest): Promise<void>;
+export {};

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

@@ -0,0 +1,66 @@
+import { hasFileExtension } from "@astrojs/internal-helpers/path";
+import { appendForwardSlash, removeTrailingForwardSlash } from "../core/path.js";
+import { runWithErrorHandling } from "./controller.js";
+import { recordServerError } from "./error.js";
+import { handle500Response } from "./response.js";
+import { handleRoute, matchRoute } from "./route.js";
+async function handleRequest({
+  pipeline,
+  routesList,
+  controller,
+  incomingRequest,
+  incomingResponse
+}) {
+  const { config, loader } = pipeline;
+  const origin = `${loader.isHttps() ? "https" : "http"}://${incomingRequest.headers[":authority"] ?? incomingRequest.headers.host}`;
+  const url = new URL(origin + incomingRequest.url);
+  let pathname;
+  if (config.trailingSlash === "never" && !incomingRequest.url) {
+    pathname = "";
+  } else {
+    pathname = decodeURI(url.pathname);
+  }
+  url.pathname = removeTrailingForwardSlash(config.base) + url.pathname;
+  if (config.trailingSlash === "never") {
+    url.pathname = removeTrailingForwardSlash(url.pathname);
+  } else if (config.trailingSlash === "always" && !hasFileExtension(url.pathname)) {
+    url.pathname = appendForwardSlash(url.pathname);
+  }
+  let body = void 0;
+  if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
+    let bytes = [];
+    await new Promise((resolve) => {
+      incomingRequest.on("data", (part) => {
+        bytes.push(part);
+      });
+      incomingRequest.on("end", resolve);
+    });
+    body = Buffer.concat(bytes);
+  }
+  await runWithErrorHandling({
+    controller,
+    pathname,
+    async run() {
+      const matchedRoute = await matchRoute(pathname, routesList, pipeline);
+      const resolvedPathname = matchedRoute?.resolvedPathname ?? pathname;
+      return await handleRoute({
+        matchedRoute,
+        url,
+        pathname: resolvedPathname,
+        body,
+        pipeline,
+        routesList,
+        incomingRequest,
+        incomingResponse
+      });
+    },
+    onError(_err) {
+      const { error, errorWithMetadata } = recordServerError(loader, config, pipeline, _err);
+      handle500Response(loader, incomingResponse, errorWithMetadata);
+      return error;
+    }
+  });
+}
+export {
+  handleRequest
+};

node_modules/astro/dist/vite-plugin-astro-server/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleLoader } from '../core/module-loader/index.js';
+export declare function createResolve(loader: ModuleLoader, root: URL): (s: string) => Promise<string>;

node_modules/astro/dist/vite-plugin-astro-server/resolve.js

@@ -0,0 +1,9 @@
+import { resolveIdToUrl } from "../core/viteUtils.js";
+function createResolve(loader, root) {
+  return async function(s) {
+    return await resolveIdToUrl(loader, s, root);
+  };
+}
+export {
+  createResolve
+};

node_modules/astro/dist/vite-plugin-astro-server/response.d.ts

@@ -0,0 +1,8 @@
+import type http from 'node:http';
+import type { ErrorWithMetadata } from '../core/errors/index.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+export declare function handle500Response(loader: ModuleLoader, res: http.ServerResponse, err: ErrorWithMetadata): Promise<void>;
+export declare function writeHtmlResponse(res: http.ServerResponse, statusCode: number, html: string): void;
+export declare function writeRedirectResponse(res: http.ServerResponse, statusCode: number, location: string): void;
+export declare function writeWebResponse(res: http.ServerResponse, webResponse: Response): Promise<void>;
+export declare function writeSSRResult(webRequest: Request, webResponse: Response, res: http.ServerResponse): Promise<void>;

node_modules/astro/dist/vite-plugin-astro-server/response.js

@@ -0,0 +1,96 @@
+import { Http2ServerResponse } from "node:http2";
+import { Readable } from "node:stream";
+import { getSetCookiesFromResponse } from "../core/cookies/index.js";
+import { getViteErrorPayload } from "../core/errors/dev/index.js";
+import { redirectTemplate } from "../core/routing/3xx.js";
+async function handle500Response(loader, res, err) {
+  res.on(
+    "close",
+    async () => setTimeout(async () => loader.webSocketSend(await getViteErrorPayload(err)), 200)
+  );
+  if (res.headersSent) {
+    res.write(`<script type="module" src="/@vite/client"></script>`);
+    res.end();
+  } else {
+    writeHtmlResponse(
+      res,
+      500,
+      `<title>${err.name}</title><script type="module" src="/@vite/client"></script>`
+    );
+  }
+}
+function writeHtmlResponse(res, statusCode, html) {
+  res.writeHead(statusCode, {
+    "Content-Type": "text/html",
+    "Content-Length": Buffer.byteLength(html, "utf-8")
+  });
+  res.write(html);
+  res.end();
+}
+function writeRedirectResponse(res, statusCode, location) {
+  const html = redirectTemplate({
+    status: statusCode,
+    absoluteLocation: location,
+    relativeLocation: location
+  });
+  res.writeHead(statusCode, {
+    Location: location,
+    "Content-Type": "text/html",
+    "Content-Length": Buffer.byteLength(html, "utf-8")
+  });
+  res.write(html);
+  res.end();
+}
+async function writeWebResponse(res, webResponse) {
+  const { status, headers, body, statusText } = webResponse;
+  const setCookieHeaders = Array.from(getSetCookiesFromResponse(webResponse));
+  if (setCookieHeaders.length) {
+    res.setHeader("set-cookie", setCookieHeaders);
+  }
+  const _headers = Object.fromEntries(headers.entries());
+  if (headers.has("set-cookie")) {
+    _headers["set-cookie"] = headers.getSetCookie();
+  }
+  if (!(res instanceof Http2ServerResponse)) {
+    res.statusMessage = statusText;
+  }
+  res.writeHead(status, _headers);
+  if (body) {
+    if (Symbol.for("astro.responseBody") in webResponse) {
+      let stream = webResponse[Symbol.for("astro.responseBody")];
+      for await (const chunk of stream) {
+        res.write(chunk.toString());
+      }
+    } else if (body instanceof Readable) {
+      body.pipe(res);
+      return;
+    } else if (typeof body === "string") {
+      res.write(body);
+    } else {
+      const reader = body.getReader();
+      res.on("close", () => {
+        reader.cancel().catch(() => {
+        });
+      });
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) {
+          res.write(value);
+        }
+      }
+    }
+  }
+  res.end();
+}
+async function writeSSRResult(webRequest, webResponse, res) {
+  Reflect.set(webRequest, Symbol.for("astro.responseSent"), true);
+  return writeWebResponse(res, webResponse);
+}
+export {
+  handle500Response,
+  writeHtmlResponse,
+  writeRedirectResponse,
+  writeSSRResult,
+  writeWebResponse
+};

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

@@ -0,0 +1,25 @@
+import type http from 'node:http';
+import type { ComponentInstance, RoutesList } from '../types/astro.js';
+import type { RouteData } from '../types/public/internal.js';
+import type { DevPipeline } from './pipeline.js';
+type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (...args: any) => Promise<infer R> ? R : any;
+interface MatchedRoute {
+    route: RouteData;
+    filePath: URL;
+    resolvedPathname: string;
+    preloadedComponent: ComponentInstance;
+    mod: ComponentInstance;
+}
+export declare function matchRoute(pathname: string, routesList: RoutesList, pipeline: DevPipeline): Promise<MatchedRoute | undefined>;
+interface HandleRoute {
+    matchedRoute: AsyncReturnType<typeof matchRoute>;
+    url: URL;
+    pathname: string;
+    body: BodyInit | undefined;
+    routesList: RoutesList;
+    incomingRequest: http.IncomingMessage;
+    incomingResponse: http.ServerResponse;
+    pipeline: DevPipeline;
+}
+export declare function handleRoute({ matchedRoute, url, pathname, body, pipeline, routesList, incomingRequest, incomingResponse, }: HandleRoute): Promise<void>;
+export {};

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

@@ -0,0 +1,283 @@
+import { loadActions } from "../actions/loadActions.js";
+import {
+  clientLocalsSymbol,
+  DEFAULT_404_COMPONENT,
+  NOOP_MIDDLEWARE_HEADER,
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY
+} from "../core/constants.js";
+import { AstroErrorData, isAstroError } from "../core/errors/index.js";
+import { req } from "../core/messages.js";
+import { loadMiddleware } from "../core/middleware/loadMiddleware.js";
+import { routeIsRedirect } from "../core/redirects/index.js";
+import { getProps } from "../core/render/index.js";
+import { RenderContext } from "../core/render-context.js";
+import { createRequest } from "../core/request.js";
+import { redirectTemplate } from "../core/routing/3xx.js";
+import { matchAllRoutes } from "../core/routing/index.js";
+import { isRoute404, isRoute500 } from "../core/routing/match.js";
+import { PERSIST_SYMBOL } from "../core/session.js";
+import { getSortedPreloadedMatches } from "../prerender/routing.js";
+import { writeSSRResult, writeWebResponse } from "./response.js";
+function isLoggedRequest(url) {
+  return url !== "/favicon.ico";
+}
+function getCustom404Route(manifestData) {
+  return manifestData.routes.find((r) => isRoute404(r.route));
+}
+function getCustom500Route(manifestData) {
+  return manifestData.routes.find((r) => isRoute500(r.route));
+}
+async function matchRoute(pathname, routesList, pipeline) {
+  const { config, logger, routeCache, serverLike, settings } = pipeline;
+  const matches = matchAllRoutes(pathname, routesList);
+  const preloadedMatches = await getSortedPreloadedMatches({ pipeline, matches, settings });
+  for await (const { preloadedComponent, route: maybeRoute, filePath } of preloadedMatches) {
+    try {
+      await getProps({
+        mod: preloadedComponent,
+        routeData: maybeRoute,
+        routeCache,
+        pathname,
+        logger,
+        serverLike,
+        base: config.base
+      });
+      return {
+        route: maybeRoute,
+        filePath,
+        resolvedPathname: pathname,
+        preloadedComponent,
+        mod: preloadedComponent
+      };
+    } catch (e) {
+      if (isAstroError(e) && e.title === AstroErrorData.NoMatchingStaticPathFound.title) {
+        continue;
+      }
+      throw e;
+    }
+  }
+  const altPathname = pathname.replace(/\/index\.html$/, "/").replace(/\.html$/, "");
+  if (altPathname !== pathname) {
+    return await matchRoute(altPathname, routesList, pipeline);
+  }
+  if (matches.length) {
+    const possibleRoutes = matches.flatMap((route) => route.component);
+    logger.warn(
+      "router",
+      `${AstroErrorData.NoMatchingStaticPathFound.message(
+        pathname
+      )}
+
+${AstroErrorData.NoMatchingStaticPathFound.hint(possibleRoutes)}`
+    );
+  }
+  const custom404 = getCustom404Route(routesList);
+  if (custom404) {
+    const filePath = new URL(`./${custom404.component}`, config.root);
+    const preloadedComponent = await pipeline.preload(custom404, filePath);
+    return {
+      route: custom404,
+      filePath,
+      resolvedPathname: pathname,
+      preloadedComponent,
+      mod: preloadedComponent
+    };
+  }
+  return void 0;
+}
+async function handleRoute({
+  matchedRoute,
+  url,
+  pathname,
+  body,
+  pipeline,
+  routesList,
+  incomingRequest,
+  incomingResponse
+}) {
+  const timeStart = performance.now();
+  const { config, loader, logger } = pipeline;
+  if (!matchedRoute) {
+    throw new Error("No route matched, and default 404 route was not found.");
+  }
+  let request;
+  let renderContext;
+  let mod = void 0;
+  let route;
+  const actions = await loadActions(loader);
+  pipeline.setActions(actions);
+  const middleware = (await loadMiddleware(loader)).onRequest;
+  const locals = Reflect.get(incomingRequest, clientLocalsSymbol);
+  const { preloadedComponent } = matchedRoute;
+  route = matchedRoute.route;
+  request = createRequest({
+    url,
+    headers: incomingRequest.headers,
+    method: incomingRequest.method,
+    body,
+    logger,
+    isPrerendered: route.prerender,
+    routePattern: route.component
+  });
+  for (const [name, value] of Object.entries(config.server.headers ?? {})) {
+    if (value) incomingResponse.setHeader(name, value);
+  }
+  mod = preloadedComponent;
+  renderContext = await RenderContext.create({
+    locals,
+    pipeline,
+    pathname,
+    middleware: isDefaultPrerendered404(matchedRoute.route) ? void 0 : middleware,
+    request,
+    routeData: route,
+    clientAddress: incomingRequest.socket.remoteAddress,
+    actions,
+    shouldInjectCspMetaTags: false
+  });
+  let response;
+  let statusCode = 200;
+  let isReroute = false;
+  let isRewrite = false;
+  async function renderError(err, skipMiddleware) {
+    const custom500 = getCustom500Route(routesList);
+    if (!custom500) {
+      throw err;
+    }
+    try {
+      const filePath500 = new URL(`./${custom500.component}`, config.root);
+      const preloaded500Component = await pipeline.preload(custom500, filePath500);
+      renderContext = await RenderContext.create({
+        locals,
+        pipeline,
+        pathname,
+        middleware: skipMiddleware ? void 0 : middleware,
+        request,
+        routeData: route,
+        clientAddress: incomingRequest.socket.remoteAddress,
+        actions,
+        shouldInjectCspMetaTags: false
+      });
+      renderContext.props.error = err;
+      const _response = await renderContext.render(preloaded500Component);
+      logger.error("router", err.stack || err.message);
+      statusCode = 500;
+      return _response;
+    } catch (_err) {
+      if (isAstroError(_err) && [
+        AstroErrorData.MiddlewareNoDataOrNextCalled.name,
+        AstroErrorData.MiddlewareNotAResponse.name
+      ].includes(_err.name)) {
+        throw _err;
+      }
+      if (skipMiddleware === false) {
+        return renderError(_err, true);
+      }
+      throw _err;
+    }
+  }
+  try {
+    response = await renderContext.render(mod);
+    isReroute = response.headers.has(REROUTE_DIRECTIVE_HEADER);
+    isRewrite = response.headers.has(REWRITE_DIRECTIVE_HEADER_KEY);
+    const statusCodedMatched = getStatusByMatchedRoute(matchedRoute);
+    statusCode = isRewrite ? (
+      // Ignore `matchedRoute` status for rewrites
+      response.status
+    ) : (
+      // Our internal noop middleware sets a particular header. If the header isn't present, it means that the user have
+      // their own middleware, so we need to return what the user returns.
+      !response.headers.has(NOOP_MIDDLEWARE_HEADER) && !isReroute ? response.status : statusCodedMatched ?? response.status
+    );
+  } catch (err) {
+    response = await renderError(err, false);
+  } finally {
+    renderContext.session?.[PERSIST_SYMBOL]();
+  }
+  if (isLoggedRequest(pathname)) {
+    const timeEnd = performance.now();
+    logger.info(
+      null,
+      req({
+        url: pathname,
+        method: incomingRequest.method,
+        statusCode,
+        isRewrite,
+        reqTime: timeEnd - timeStart
+      })
+    );
+  }
+  if (statusCode === 404 && // If the body isn't null, that means the user sets the 404 status
+  // but uses the current route to handle the 404
+  response.body === null && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
+    const fourOhFourRoute = await matchRoute("/404", routesList, pipeline);
+    if (fourOhFourRoute) {
+      renderContext = await RenderContext.create({
+        locals,
+        pipeline,
+        pathname,
+        middleware: isDefaultPrerendered404(fourOhFourRoute.route) ? void 0 : middleware,
+        request,
+        routeData: fourOhFourRoute.route,
+        clientAddress: incomingRequest.socket.remoteAddress,
+        shouldInjectCspMetaTags: false
+      });
+      response = await renderContext.render(fourOhFourRoute.preloadedComponent);
+    }
+  }
+  if (isReroute) {
+    response.headers.delete(REROUTE_DIRECTIVE_HEADER);
+  }
+  if (isRewrite) {
+    response.headers.delete(REROUTE_DIRECTIVE_HEADER);
+  }
+  if (route.type === "endpoint") {
+    await writeWebResponse(incomingResponse, response);
+    return;
+  }
+  if (isRewrite) {
+    await writeSSRResult(request, response, incomingResponse);
+    return;
+  }
+  if (response.status < 400 && response.status >= 300) {
+    if (response.status >= 300 && response.status < 400 && routeIsRedirect(route) && !config.build.redirects && pipeline.settings.buildOutput === "static") {
+      const location = response.headers.get("location");
+      response = new Response(
+        redirectTemplate({
+          status: response.status,
+          absoluteLocation: location,
+          relativeLocation: location,
+          from: pathname
+        }),
+        {
+          status: 200,
+          headers: {
+            ...response.headers,
+            "content-type": "text/html"
+          }
+        }
+      );
+    }
+    await writeSSRResult(request, response, incomingResponse);
+    return;
+  }
+  if (response.status !== statusCode) {
+    response = new Response(response.body, {
+      status: statusCode,
+      headers: response.headers
+    });
+  }
+  await writeSSRResult(request, response, incomingResponse);
+}
+function getStatusByMatchedRoute(matchedRoute) {
+  if (matchedRoute?.route.route === "/404") return 404;
+  if (matchedRoute?.route.route === "/500") return 500;
+  return void 0;
+}
+function isDefaultPrerendered404(route) {
+  return route.route === "/404" && route.prerender && route.component === DEFAULT_404_COMPONENT;
+}
+export {
+  handleRoute,
+  matchRoute
+};

node_modules/astro/dist/vite-plugin-astro-server/server-state.d.ts

@@ -0,0 +1,15 @@
+type ErrorState = 'fresh' | 'error';
+interface RouteState {
+    state: ErrorState;
+    error?: Error;
+}
+export interface ServerState {
+    routes: Map<string, RouteState>;
+    state: ErrorState;
+    error?: Error;
+}
+export declare function createServerState(): ServerState;
+export declare function setRouteError(serverState: ServerState, pathname: string, error: Error): void;
+export declare function setServerError(serverState: ServerState, error: Error): void;
+export declare function clearRouteError(serverState: ServerState, pathname: string): void;
+export {};

node_modules/astro/dist/vite-plugin-astro-server/server-state.js

@@ -0,0 +1,38 @@
+function createServerState() {
+  return {
+    routes: /* @__PURE__ */ new Map(),
+    state: "fresh"
+  };
+}
+function setRouteError(serverState, pathname, error) {
+  if (serverState.routes.has(pathname)) {
+    const routeState = serverState.routes.get(pathname);
+    routeState.state = "error";
+    routeState.error = error;
+  } else {
+    const routeState = {
+      state: "error",
+      error
+    };
+    serverState.routes.set(pathname, routeState);
+  }
+  serverState.state = "error";
+  serverState.error = error;
+}
+function setServerError(serverState, error) {
+  serverState.state = "error";
+  serverState.error = error;
+}
+function clearRouteError(serverState, pathname) {
+  if (serverState.routes.has(pathname)) {
+    serverState.routes.delete(pathname);
+  }
+  serverState.state = "fresh";
+  serverState.error = void 0;
+}
+export {
+  clearRouteError,
+  createServerState,
+  setRouteError,
+  setServerError
+};

node_modules/astro/dist/vite-plugin-astro-server/trailing-slash.d.ts

@@ -0,0 +1,3 @@
+import type * as vite from 'vite';
+import type { AstroSettings } from '../types/astro.js';
+export declare function trailingSlashMiddleware(settings: AstroSettings): vite.Connect.NextHandleFunction;

node_modules/astro/dist/vite-plugin-astro-server/trailing-slash.js

@@ -0,0 +1,34 @@
+import {
+  collapseDuplicateTrailingSlashes,
+  hasFileExtension,
+  isInternalPath
+} from "@astrojs/internal-helpers/path";
+import { trailingSlashMismatchTemplate } from "../template/4xx.js";
+import { writeHtmlResponse, writeRedirectResponse } from "./response.js";
+function trailingSlashMiddleware(settings) {
+  const { trailingSlash } = settings.config;
+  return function devTrailingSlash(req, res, next) {
+    const url = new URL(`http://localhost${req.url}`);
+    let pathname;
+    try {
+      pathname = decodeURI(url.pathname);
+    } catch (e) {
+      return next(e);
+    }
+    if (isInternalPath(pathname)) {
+      return next();
+    }
+    const destination = collapseDuplicateTrailingSlashes(pathname, true);
+    if (pathname && destination !== pathname) {
+      return writeRedirectResponse(res, 301, `${destination}${url.search}`);
+    }
+    if (trailingSlash === "never" && pathname.endsWith("/") && pathname !== "/" || trailingSlash === "always" && !pathname.endsWith("/") && !hasFileExtension(pathname)) {
+      const html = trailingSlashMismatchTemplate(pathname, trailingSlash);
+      return writeHtmlResponse(res, 404, html);
+    }
+    return next();
+  };
+}
+export {
+  trailingSlashMiddleware
+};

node_modules/astro/dist/vite-plugin-astro-server/util.d.ts

@@ -0,0 +1,3 @@
+import { isCSSRequest } from 'vite';
+export { isCSSRequest };
+export declare const isBuildableCSSRequest: (request: string) => boolean;

node_modules/astro/dist/vite-plugin-astro-server/util.js

@@ -0,0 +1,8 @@
+import { isCSSRequest } from "vite";
+const rawRE = /(?:\?|&)raw(?:&|$)/;
+const inlineRE = /(?:\?|&)inline\b/;
+const isBuildableCSSRequest = (request) => isCSSRequest(request) && !rawRE.test(request) && !inlineRE.test(request);
+export {
+  isBuildableCSSRequest,
+  isCSSRequest
+};

node_modules/astro/dist/vite-plugin-astro-server/vite.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleLoader, ModuleNode } from '../core/module-loader/index.js';
+/** recursively crawl the module graph to get all style files imported by parent id */
+export declare function crawlGraph(loader: ModuleLoader, _id: string, isRootFile: boolean, scanned?: Set<string>): AsyncGenerator<ModuleNode, void, unknown>;

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

@@ -0,0 +1,72 @@
+import npath from "node:path";
+import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "../core/constants.js";
+import { unwrapId } from "../core/util.js";
+import { hasSpecialQueries } from "../vite-plugin-utils/index.js";
+import { isCSSRequest } from "./util.js";
+const fileExtensionsToSSR = /* @__PURE__ */ new Set([".astro", ".mdoc", ...SUPPORTED_MARKDOWN_FILE_EXTENSIONS]);
+const STRIP_QUERY_PARAMS_REGEX = /\?.*$/;
+async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ new Set()) {
+  const id = unwrapId(_id);
+  const importedModules = /* @__PURE__ */ new Set();
+  const moduleEntriesForId = isRootFile ? (
+    // "getModulesByFile" pulls from a delayed module cache (fun implementation detail),
+    // So we can get up-to-date info on initial server load.
+    // Needed for slower CSS preprocessing like Tailwind
+    loader.getModulesByFile(id) ?? /* @__PURE__ */ new Set()
+  ) : (
+    // For non-root files, we're safe to pull from "getModuleById" based on testing.
+    // TODO: Find better invalidation strategy to use "getModuleById" in all cases!
+    /* @__PURE__ */ new Set([loader.getModuleById(id)])
+  );
+  for (const entry of moduleEntriesForId) {
+    if (!entry) {
+      continue;
+    }
+    if (id === entry.id) {
+      scanned.add(id);
+      if (isCSSRequest(id)) {
+        continue;
+      }
+      if (hasSpecialQueries(id)) {
+        continue;
+      }
+      for (const importedModule of entry.importedModules) {
+        if (!importedModule.id) continue;
+        const importedModulePathname = importedModule.id.replace(STRIP_QUERY_PARAMS_REGEX, "");
+        const isFileTypeNeedingSSR = fileExtensionsToSSR.has(npath.extname(importedModulePathname));
+        const isPropagationStoppingPoint = importedModule.id.includes("?astroPropagatedAssets");
+        if (isFileTypeNeedingSSR && // Should not SSR a module with ?astroPropagatedAssets
+        !isPropagationStoppingPoint) {
+          const mod = loader.getModuleById(importedModule.id);
+          if (!mod?.ssrModule) {
+            try {
+              await loader.import(importedModule.id);
+            } catch {
+            }
+          }
+        }
+        if (isImportedBy(id, importedModule) && !isPropagationStoppingPoint) {
+          importedModules.add(importedModule);
+        }
+      }
+    }
+  }
+  for (const importedModule of importedModules) {
+    if (!importedModule.id || scanned.has(importedModule.id)) {
+      continue;
+    }
+    yield importedModule;
+    yield* crawlGraph(loader, importedModule.id, false, scanned);
+  }
+}
+function isImportedBy(parent, entry) {
+  for (const importer of entry.importers) {
+    if (importer.id === parent) {
+      return true;
+    }
+  }
+  return false;
+}
+export {
+  crawlGraph
+};