astro 5.1.10 → 5.2.1

package/dist/core/sync/index.js

@@ -13,6 +13,7 @@ import { syncAstroEnv } from "../../env/sync.js";
 import { telemetry } from "../../events/index.js";
 import { eventCliSession } from "../../events/session.js";
 import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
+import { createDevelopmentManifest } from "../../vite-plugin-astro-server/plugin.js";
 import { getTimeStat } from "../build/util.js";
 import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
@@ -25,7 +26,7 @@ import {
   createSafeError,
   isAstroError
 } from "../errors/index.js";
-import { createRouteManifest } from "../routing/index.js";
+import { createRoutesList } from "../routing/index.js";
 import { ensureProcessNodeEnv } from "../util.js";
 import { normalizePath } from "../viteUtils.js";
 async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
@@ -41,7 +42,8 @@ async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
     settings,
     logger
   });
-  const manifest = await createRouteManifest({ settings, fsMod: fs }, logger);
+  const routesList = await createRoutesList({ settings, fsMod: fs }, logger);
+  const manifest = createDevelopmentManifest(settings);
   await runHookConfigDone({ settings, logger });
   return await syncInternal({
     settings,
@@ -49,8 +51,9 @@ async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
     mode: "production",
     fs,
     force: inlineConfig.force,
-    manifest,
-    command: "sync"
+    routesList,
+    command: "sync",
+    manifest
   });
 }
 async function clearContentLayerCache({
@@ -73,9 +76,10 @@ async function syncInternal({
   settings,
   skip,
   force,
-  manifest,
+  routesList,
   command,
-  watcher
+  watcher,
+  manifest
 }) {
   const isDev = command === "dev";
   if (force) {
@@ -83,7 +87,7 @@ async function syncInternal({
   }
   const timerStart = performance.now();
   if (!skip?.content) {
-    await syncContentCollections(settings, { mode, fs, logger, manifest });
+    await syncContentCollections(settings, { mode, fs, logger, routesList, manifest });
     settings.timer.start("Sync content layer");
     let store;
     try {
@@ -152,6 +156,7 @@ async function syncContentCollections(settings, {
   mode,
   logger,
   fs,
+  routesList,
   manifest
 }) {
   const tempViteServer = await createServer(
@@ -162,7 +167,7 @@ async function syncContentCollections(settings, {
         ssr: { external: [] },
         logLevel: "silent"
       },
-      { settings, logger, mode, command: "build", fs, sync: true, manifest }
+      { settings, logger, mode, command: "build", fs, sync: true, routesList, manifest }
     )
   );
   const hotSend = tempViteServer.hot.send;

package/dist/i18n/utils.d.ts

@@ -1,3 +1,4 @@
+import type { SSRManifest } from '../core/app/types.js';
 import type { AstroConfig, Locales } from '../types/public/config.js';
 type BrowserLocale = {
     locale: string;
@@ -23,5 +24,6 @@ export declare function computePreferredLocaleList(request: Request, locales: Lo
 export declare function computeCurrentLocale(pathname: string, locales: Locales, defaultLocale: string): string | undefined;
 export type RoutingStrategies = 'manual' | 'pathname-prefix-always' | 'pathname-prefix-other-locales' | 'pathname-prefix-always-no-redirect' | 'domains-prefix-always' | 'domains-prefix-other-locales' | 'domains-prefix-always-no-redirect';
 export declare function toRoutingStrategy(routing: NonNullable<AstroConfig['i18n']>['routing'], domains: NonNullable<AstroConfig['i18n']>['domains']): RoutingStrategies;
+export declare function fromRoutingStrategy(strategy: RoutingStrategies, fallbackType: NonNullable<SSRManifest['i18n']>['fallbackType']): NonNullable<AstroConfig['i18n']>['routing'];
 export declare function toFallbackType(routing: NonNullable<AstroConfig['i18n']>['routing']): 'redirect' | 'rewrite';
 export {};

package/dist/i18n/utils.js

@@ -168,6 +168,29 @@ function toRoutingStrategy(routing, domains) {
   }
   return strategy;
 }
+const PREFIX_DEFAULT_LOCALE = /* @__PURE__ */ new Set([
+  "pathname-prefix-always",
+  "domains-prefix-always",
+  "pathname-prefix-always-no-redirect",
+  "domains-prefix-always-no-redirect"
+]);
+const REDIRECT_TO_DEFAULT_LOCALE = /* @__PURE__ */ new Set([
+  "pathname-prefix-always-no-redirect",
+  "domains-prefix-always-no-redirect"
+]);
+function fromRoutingStrategy(strategy, fallbackType) {
+  let routing;
+  if (strategy === "manual") {
+    routing = "manual";
+  } else {
+    routing = {
+      prefixDefaultLocale: PREFIX_DEFAULT_LOCALE.has(strategy),
+      redirectToDefaultLocale: !REDIRECT_TO_DEFAULT_LOCALE.has(strategy),
+      fallbackType
+    };
+  }
+  return routing;
+}
 function toFallbackType(routing) {
   if (routing === "manual") {
     return "rewrite";
@@ -178,6 +201,7 @@ export {
   computeCurrentLocale,
   computePreferredLocale,
   computePreferredLocaleList,
+  fromRoutingStrategy,
   parseLocale,
   toFallbackType,
   toRoutingStrategy

package/dist/manifest/virtual-module.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from 'vite';
+import type { Logger } from '../core/logger/core.js';
+import type { AstroSettings } from '../types/astro.js';
+import type { SSRManifest } from '../types/public/index.js';
+export default function virtualModulePlugin({ settings, manifest, logger: _logger, }: {
+    settings: AstroSettings;
+    manifest: SSRManifest;
+    logger: Logger;
+}): Plugin;

package/dist/manifest/virtual-module.js

@@ -0,0 +1,111 @@
+import { CantUseAstroConfigModuleError } from "../core/errors/errors-data.js";
+import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { fromRoutingStrategy } from "../i18n/utils.js";
+const VIRTUAL_SERVER_ID = "astro:config/server";
+const RESOLVED_VIRTUAL_SERVER_ID = "\0" + VIRTUAL_SERVER_ID;
+const VIRTUAL_CLIENT_ID = "astro:config/client";
+const RESOLVED_VIRTUAL_CLIENT_ID = "\0" + VIRTUAL_CLIENT_ID;
+function virtualModulePlugin({
+  settings,
+  manifest,
+  logger: _logger
+}) {
+  return {
+    enforce: "pre",
+    name: "astro-manifest-plugin",
+    resolveId(id) {
+      if (VIRTUAL_SERVER_ID === id) {
+        return RESOLVED_VIRTUAL_SERVER_ID;
+      } else if (VIRTUAL_CLIENT_ID === id) {
+        return RESOLVED_VIRTUAL_CLIENT_ID;
+      }
+    },
+    load(id, opts) {
+      if (id === RESOLVED_VIRTUAL_CLIENT_ID) {
+        if (!settings.config.experimental.serializeConfig) {
+          throw new AstroError({
+            ...CantUseAstroConfigModuleError,
+            message: CantUseAstroConfigModuleError.message(VIRTUAL_CLIENT_ID)
+          });
+        }
+        return `${serializeClientConfig(manifest)};`;
+      } else if (id == RESOLVED_VIRTUAL_SERVER_ID) {
+        if (!settings.config.experimental.serializeConfig) {
+          throw new AstroError({
+            ...CantUseAstroConfigModuleError,
+            message: CantUseAstroConfigModuleError.message(VIRTUAL_SERVER_ID)
+          });
+        }
+        if (!opts?.ssr) {
+          throw new AstroError({
+            ...AstroErrorData.ServerOnlyModule,
+            message: AstroErrorData.ServerOnlyModule.message(VIRTUAL_SERVER_ID)
+          });
+        }
+        return `${serializeServerConfig(manifest)};`;
+      }
+    }
+  };
+}
+function serializeClientConfig(manifest) {
+  let i18n = void 0;
+  if (manifest.i18n) {
+    i18n = {
+      defaultLocale: manifest.i18n.defaultLocale,
+      locales: manifest.i18n.locales,
+      routing: fromRoutingStrategy(manifest.i18n.strategy, manifest.i18n.fallbackType),
+      fallback: manifest.i18n.fallback
+    };
+  }
+  const serClientConfig = {
+    base: manifest.base,
+    i18n,
+    build: {
+      format: manifest.buildFormat
+    },
+    trailingSlash: manifest.trailingSlash,
+    compressHTML: manifest.compressHTML,
+    site: manifest.site
+  };
+  const output = [];
+  for (const [key, value] of Object.entries(serClientConfig)) {
+    output.push(`export const ${key} = ${JSON.stringify(value)};`);
+  }
+  return output.join("\n") + "\n";
+}
+function serializeServerConfig(manifest) {
+  let i18n = void 0;
+  if (manifest.i18n) {
+    i18n = {
+      defaultLocale: manifest.i18n.defaultLocale,
+      routing: fromRoutingStrategy(manifest.i18n.strategy, manifest.i18n.fallbackType),
+      locales: manifest.i18n.locales,
+      fallback: manifest.i18n.fallback
+    };
+  }
+  const serverConfig = {
+    build: {
+      server: new URL(manifest.buildServerDir),
+      client: new URL(manifest.buildClientDir),
+      format: manifest.buildFormat
+    },
+    cacheDir: new URL(manifest.cacheDir),
+    outDir: new URL(manifest.outDir),
+    publicDir: new URL(manifest.publicDir),
+    srcDir: new URL(manifest.srcDir),
+    root: new URL(manifest.hrefRoot),
+    base: manifest.base,
+    i18n,
+    trailingSlash: manifest.trailingSlash,
+    site: manifest.site,
+    compressHTML: manifest.compressHTML
+  };
+  const output = [];
+  for (const [key, value] of Object.entries(serverConfig)) {
+    output.push(`export const ${key} = ${JSON.stringify(value)};`);
+  }
+  return output.join("\n") + "\n";
+}
+export {
+  virtualModulePlugin as default
+};

package/dist/template/4xx.d.ts

@@ -13,5 +13,6 @@ interface ErrorTemplateOptions {
 /** Display all errors */
 export default function template({ title, pathname, statusCode, tabTitle, body, }: ErrorTemplateOptions): string;
 export declare function subpathNotUsedTemplate(base: string, pathname: string): string;
+export declare function trailingSlashMismatchTemplate(pathname: string, trailingSlash: 'always' | 'never' | 'ignore'): string;
 export declare function notFoundTemplate(pathname: string, message?: string): string;
 export {};

package/dist/template/4xx.js

@@ -1,3 +1,4 @@
+import { appendForwardSlash, removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
 import { escape } from "html-escaper";
 function template({
   title,
@@ -107,6 +108,17 @@ function subpathNotUsedTemplate(base, pathname) {
 <p>Come to our <a href="https://astro.build/chat">Discord</a> if you need help.</p>`
   });
 }
+function trailingSlashMismatchTemplate(pathname, trailingSlash) {
+  const corrected = trailingSlash === "always" ? appendForwardSlash(pathname) : removeTrailingForwardSlash(pathname);
+  return template({
+    pathname,
+    statusCode: 404,
+    title: "Not found",
+    tabTitle: "404: Not Found",
+    body: `<p>Your site is configured with <code>trailingSlash</code> set to <code>${trailingSlash}</code>. Do you want to go to <a href="${corrected}">${corrected}</a> instead?</p>
+<p>See <a href=https://docs.astro.build/en/reference/configuration-reference/#trailingslash">the documentation for <code>trailingSlash</code></a> if you need help.</p>`
+  });
+}
 function notFoundTemplate(pathname, message = "Not found") {
   return template({
     pathname,
@@ -118,5 +130,6 @@ function notFoundTemplate(pathname, message = "Not found") {
 export {
   template as default,
   notFoundTemplate,
-  subpathNotUsedTemplate
+  subpathNotUsedTemplate,
+  trailingSlashMismatchTemplate
 };

package/dist/types/astro.d.ts

@@ -72,7 +72,7 @@ export interface ComponentInstance {
     prerender?: boolean;
     getStaticPaths?: (options: GetStaticPathsOptions) => GetStaticPathsResult;
 }
-export interface ManifestData {
+export interface RoutesList {
     routes: RouteData[];
 }
 export interface AstroPluginOptions {

package/dist/types/public/config.d.ts

@@ -13,7 +13,7 @@ import type { LoggerLevel } from '../../core/logger/core.js';
 import type { EnvSchema } from '../../env/schema.js';
 import type { AstroIntegration } from './integrations.js';
 export type Locales = (string | {
-    codes: string[];
+    codes: [string, ...string[]];
     path: string;
 })[];
 type NormalizeLocales<T extends Locales> = {
@@ -193,14 +193,15 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
      * @see build.format
      * @description
      *
-     * Set the route matching behavior of the dev server. Choose from the following options:
-     *   - `'always'` - Only match URLs that include a trailing slash (ex: "/foo/")
-     *   - `'never'` - Never match URLs that include a trailing slash (ex: "/foo")
-     *   - `'ignore'` - Match URLs regardless of whether a trailing "/" exists
+     * Set the route matching behavior for trailing slashes in the dev server and on-demand rendered pages. Choose from the following options:
+     *   - `'ignore'` - Match URLs regardless of whether a trailing "/" exists. Requests for "/about" and "/about/" will both match the same route.
+     *   - `'always'` - Only match URLs that include a trailing slash (e.g: "/about/"). In production, requests for on-demand rendered URLs without a trailing slash will be redirected to the correct URL for your convenience. However, in development, they will display a warning page reminding you that you have `always` configured.
+     *   - `'never'` - Only match URLs that do not include a trailing slash (e.g: "/about"). In production, requests for on-demand rendered URLs with a trailing slash will be redirected to the correct URL for your convenience. However, in development, they will display a warning page reminding you that you have `never` configured.
      *
-     * Use this configuration option if your production host has strict handling of how trailing slashes work or do not work.
+     * When redirects occur in production for GET requests, the redirect will be a 301 (permanent) redirect. For all other request methods, it will be a 308 (permanent, and preserve the request method) redirect.
      *
-     * You can also set this if you prefer to be more strict yourself, so that URLs with or without trailing slashes won't work during development.
+     * Trailing slashes on prerendered pages are handled by the hosting platform, and may not respect your chosen configuration.
+     * See your hosting platform's documentation for more information.
      *
      * ```js
      * {
@@ -220,16 +221,21 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
      * and the value is the path to redirect to.
      *
      * You can redirect both static and dynamic routes, but only to the same kind of route.
-     * For example you cannot have a `'/article': '/blog/[...slug]'` redirect.
+     * For example, you cannot have a `'/article': '/blog/[...slug]'` redirect.
      *
      *
      * ```js
-     * {
+     * export default defineConfig({
      *   redirects: {
-     *     '/old': '/new',
-     *     '/blog/[...slug]': '/articles/[...slug]',
-     *   }
-     * }
+     *    '/old': '/new',
+     *    '/blog/[...slug]': '/articles/[...slug]',
+     *    '/about': 'https://example.com/about',
+     *    '/news': {
+     *      status: 302,
+     *      destination: 'https://example.com/news'
+     *  	}
+     * 	}
+     * })
      * ```
      *
      *
@@ -243,14 +249,14 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
      * You can customize the [redirection status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages) using an object in the redirect config:
      *
      * ```js
-     * {
+     * export default defineConfig({
      *   redirects: {
      *     '/other': {
      *       status: 302,
      *       destination: '/place',
      *     },
      *   }
-     * }
+     * })
      * ```
      */
     redirects?: Record<string, RedirectConfig>;
@@ -308,10 +314,10 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
      *
      * ```js
      * import react from '@astrojs/react';
-     * import tailwind from '@astrojs/tailwind';
+     * import mdx from '@astrojs/mdx';
      * {
-     *   // Example: Add React + Tailwind support to Astro
-     *   integrations: [react(), tailwind()]
+     *   // Example: Add React + MDX support to Astro
+     *   integrations: [react(), mdx()]
      * }
      * ```
      */
@@ -1954,6 +1960,18 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
              */
             mode: SvgRenderMode;
         };
+        /**
+         * @name experimental.serializeConfig
+         * @type {boolean}
+         * @default `false`
+         * @version 5.x
+         * @description
+         *
+         * Enables the use of the experimental virtual modules `astro:config/server` and `astro:config/client`.
+         *
+         * These two virtual modules contain a serializable subset of the Astro configuration.
+         */
+        serializeConfig?: boolean;
     };
 }
 /**

package/dist/types/public/index.d.ts

@@ -9,6 +9,7 @@ export type * from './context.js';
 export type * from './preview.js';
 export type * from './content.js';
 export type * from './common.js';
+export type * from './manifest.js';
 export type { AstroIntegrationLogger } from '../../core/logger/core.js';
 export type { ToolbarServerHelpers } from '../../runtime/client/dev-toolbar/helpers.js';
 export type { MarkdownHeading, RehypePlugins, RemarkPlugins, ShikiConfig, } from '@astrojs/markdown-remark';

package/dist/types/public/manifest.d.ts

@@ -0,0 +1,23 @@
+/**
+ * **IMPORTANT**: use the `Pick` interface to select only the properties that we want to expose
+ * to the users. Using blanket types could expose properties that we don't want. So if we decide to expose
+ * properties, we need to be good at justifying them. For example: why you need this config? can't you use an integration?
+ * why do you need access to the shiki config? (very low-level confiig)
+ */
+import type { SSRManifest } from '../../core/app/types.js';
+import type { AstroConfig } from './config.js';
+type Extend<T, U> = {
+    [K in keyof T]: T[K] | U;
+};
+type Dirs = Pick<SSRManifest, 'cacheDir' | 'outDir' | 'publicDir' | 'srcDir'>;
+type DeserializedDirs = Extend<Dirs, URL>;
+export type ServerDeserializedManifest = Pick<SSRManifest, 'base' | 'trailingSlash' | 'compressHTML' | 'site'> & DeserializedDirs & {
+    i18n: AstroConfig['i18n'];
+    build: Pick<AstroConfig['build'], 'server' | 'client' | 'format'>;
+    root: URL;
+};
+export type ClientDeserializedManifest = Pick<SSRManifest, 'base' | 'trailingSlash' | 'compressHTML' | 'site'> & {
+    i18n: AstroConfig['i18n'];
+    build: Pick<AstroConfig['build'], 'format'>;
+};
+export {};

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

@@ -2,9 +2,8 @@ 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, writeRedirectResponse } from "./response.js";
-const manySlashes = /\/{2,}$/;
+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;
@@ -13,10 +12,6 @@ function baseMiddleware(settings, logger) {
   const devRootReplacement = devRoot.endsWith("/") ? "/" : "";
   return function devBaseMiddleware(req, res, next) {
     const url = req.url;
-    if (manySlashes.test(url)) {
-      const destination = url.replace(manySlashes, "/");
-      return writeRedirectResponse(res, 301, destination);
-    }
     let pathname;
     try {
       pathname = decodeURI(new URL(url, "http://localhost").pathname);
@@ -32,12 +27,7 @@ function baseMiddleware(settings, logger) {
       return writeHtmlResponse(res, 404, html);
     }
     if (req.headers.accept?.includes("text/html")) {
-      const html = notFoundTemplate({
-        statusCode: 404,
-        title: "Not found",
-        tabTitle: "404: Not Found",
-        pathname
-      });
+      const html = notFoundTemplate(pathname);
       return writeHtmlResponse(res, 404, html);
     }
     const publicPath = new URL("." + req.url, config.publicDir);

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

@@ -2,7 +2,7 @@ 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, ManifestData } from '../types/astro.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 {
@@ -18,16 +18,16 @@ export declare class DevPipeline extends Pipeline {
         component: string;
     }[];
     renderers: SSRLoadedRenderer[];
-    manifestData: ManifestData | undefined;
+    routesList: RoutesList | undefined;
     componentInterner: WeakMap<RouteData, ComponentInstance>;
     private constructor();
-    static create(manifestData: ManifestData, { loader, logger, manifest, settings, }: Pick<DevPipeline, 'loader' | 'logger' | 'manifest' | 'settings'>): DevPipeline;
+    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: ManifestData): void;
+    setManifestData(manifestData: RoutesList): void;
     rewriteKnownRoute(route: string, sourceRoute: RouteData): ComponentInstance;
 }

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

@@ -30,7 +30,7 @@ class DevPipeline extends Pipeline {
   // renderers are loaded on every request,
   // so it needs to be mutable here unlike in other environments
   renderers = new Array();
-  manifestData;
+  routesList;
   componentInterner = /* @__PURE__ */ new WeakMap();
   static create(manifestData, {
     loader,
@@ -39,7 +39,7 @@ class DevPipeline extends Pipeline {
     settings
   }) {
     const pipeline = new DevPipeline(loader, logger, manifest, settings);
-    pipeline.manifestData = manifestData;
+    pipeline.routesList = manifestData;
     return pipeline;
   }
   async headElements(routeData) {
@@ -137,13 +137,13 @@ class DevPipeline extends Pipeline {
     }
   }
   async tryRewrite(payload, request) {
-    if (!this.manifestData) {
+    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.manifestData?.routes,
+      routes: this.routesList?.routes,
       trailingSlash: this.config.trailingSlash,
       buildFormat: this.config.build.format,
       base: this.config.base
@@ -152,7 +152,7 @@ class DevPipeline extends Pipeline {
     return { newUrl, pathname, componentInstance, routeData };
   }
   setManifestData(manifestData) {
-    this.manifestData = manifestData;
+    this.routesList = manifestData;
   }
   rewriteKnownRoute(route, sourceRoute) {
     if (this.serverLike && sourceRoute.prerender) {

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

@@ -2,15 +2,15 @@ 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, ManifestData } from '../types/astro.js';
+import type { AstroSettings, RoutesList } from '../types/astro.js';
 export interface AstroPluginOptions {
     settings: AstroSettings;
     logger: Logger;
     fs: typeof fs;
-    manifest: ManifestData;
-    ssrManifest: SSRManifest;
+    routesList: RoutesList;
+    manifest: SSRManifest;
 }
-export default function createVitePluginAstroServer({ settings, logger, fs: fsMod, manifest: routeManifest, ssrManifest: devSSRManifest, }: AstroPluginOptions): vite.Plugin;
+export default function createVitePluginAstroServer({ settings, logger, fs: fsMod, routesList, manifest, }: AstroPluginOptions): vite.Plugin;
 /**
  * It creates a `SSRManifest` from the `AstroSettings`.
  *