astro 2.5.7 → 2.6.0

package/dist/@types/astro.d.ts

@@ -73,7 +73,7 @@ export interface CLIFlags {
     drafts?: boolean;
     open?: boolean;
     experimentalAssets?: boolean;
-    experimentalMiddleware?: boolean;
+    experimentalRedirects?: boolean;
 }
 export interface BuildConfig {
     /**
@@ -396,6 +396,50 @@ export interface AstroUserConfig {
      * ```
      */
     cacheDir?: string;
+    /**
+     * @docs
+     * @name redirects (Experimental)
+     * @type {RedirectConfig}
+     * @default `{}`
+     * @version 2.6.0
+     * @description Specify a mapping of redirects where the key is the route to match
+     * 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.
+     *
+     *
+     * ```js
+     * {
+     *   redirects: {
+     *     '/old': '/new',
+     *     '/blog/[...slug]': '/articles/[...slug]',
+     *   }
+     * }
+     * ```
+     *
+     *
+     * For statically-generated sites with no adapter installed, this will produce a client redirect using a [`<meta http-equiv="refresh">` tag](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#http-equiv) and does not support status codes.
+     *
+     * When using SSR or with a static adapter in `output: static`
+     * mode, status codes are supported.
+     * Astro will serve redirected GET requests with a status of `301`
+     * and use a status of `308` for any other request method.
+     *
+     * 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
+     * {
+     *   redirects: {
+     *     '/other': {
+     *       status: 302,
+     *       destination: '/place',
+     *     },
+     *   }
+     * }
+     * ```
+     */
+    redirects?: RedirectConfig;
     /**
      * @docs
      * @name site
@@ -670,6 +714,50 @@ export interface AstroUserConfig {
          * ```
          */
         serverEntry?: string;
+        /**
+         * @docs
+         * @name build.redirects
+         * @type {boolean}
+         * @default `true`
+         * @version 2.6.0
+         * @description
+         * Specifies whether redirects will be output to HTML during the build.
+         * This option only applies to `output: 'static'` mode; in SSR redirects
+         * are treated the same as all responses.
+         *
+         * This option is mostly meant to be used by adapters that have special
+         * configuration files for redirects and do not need/want HTML based redirects.
+         *
+         * ```js
+         * {
+         *   build: {
+         *     redirects: false
+         *   }
+         * }
+         * ```
+         */
+        redirects?: boolean;
+        /**
+         * @docs
+         * @name build.inlineStylesheets
+         * @type {('always' | 'auto' | 'never')}
+         * @default `never`
+         * @version 2.6.0
+         * @description
+         * Control whether styles are sent to the browser in a separate css file or inlined into `<style>` tags. Choose from the following options:
+         *  - `'always'` - all styles are inlined into `<style>` tags
+         *  - `'auto'` - only stylesheets smaller than `ViteConfig.build.assetsInlineLimit` (default: 4kb) are inlined. Otherwise, styles are sent in external stylesheets.
+         *  - `'never'` - all styles are sent in external stylesheets
+         *
+         * ```js
+         * {
+         * 	build: {
+         *		inlineStylesheets: `auto`,
+         * 	},
+         * }
+         * ```
+         */
+        inlineStylesheets?: 'always' | 'auto' | 'never';
     };
     /**
      * @docs
@@ -1001,103 +1089,24 @@ export interface AstroUserConfig {
         assets?: boolean;
         /**
          * @docs
-         * @name experimental.inlineStylesheets
-         * @type {('always' | 'auto' | 'never')}
-         * @default `never`
-         * @version 2.4.0
-         * @description
-         * Control whether styles are sent to the browser in a separate css file or inlined into `<style>` tags. Choose from the following options:
-         *  - `'always'` - all styles are inlined into `<style>` tags
-         *  - `'auto'` - only stylesheets smaller than `ViteConfig.build.assetsInlineLimit` (default: 4kb) are inlined. Otherwise, styles are sent in external stylesheets.
-         *  - `'never'` - all styles are sent in external stylesheets
-         *
-         * ```js
-         * {
-         * 	experimental: {
-         *		inlineStylesheets: `auto`,
-         * 	},
-         * }
-         * ```
-         */
-        inlineStylesheets?: 'always' | 'auto' | 'never';
-        /**
-         * @docs
-         * @name experimental.customClientDirectives
+         * @name experimental.redirects
          * @type {boolean}
          * @default `false`
-         * @version 2.5.0
+         * @version 2.6.0
          * @description
-         * Allow integrations to use the [experimental `addClientDirective` API](/en/reference/integrations-reference/#addclientdirective-option) in the `astro:config:setup` hook
-         * to add custom client directives in Astro files.
-         *
-         * To enable this feature, set `experimental.customClientDirectives` to `true` in your Astro config:
+         * Enable experimental support for redirect configuration. With this enabled
+         * you can set redirects via the top-level `redirects` property. To enable
+         * this feature, set `experimental.redirects` to `true`.
          *
          * ```js
          * {
          * 	experimental: {
-         *		customClientDirectives: true,
+         *		redirects: true,
          * 	},
          * }
          * ```
          */
-        customClientDirectives?: boolean;
-        /**
-         * @docs
-         * @name experimental.middleware
-         * @type {boolean}
-         * @default `false`
-         * @version 2.4.0
-         * @description
-         * Enable experimental support for Astro middleware.
-         *
-         * To enable this feature, set `experimental.middleware` to `true` in your Astro config:
-         *
-         * ```js
-         * {
-         * 	experimental: {
-         *		middleware: true,
-         * 	},
-         * }
-         * ```
-         */
-        middleware?: boolean;
-        /**
-         * @docs
-         * @name experimental.hybridOutput
-         * @type {boolean}
-         * @default `false`
-         * @version 2.5.0
-         * @description
-         * Enable experimental support for hybrid SSR with pre-rendering enabled by default.
-         *
-         * To enable this feature, first set `experimental.hybridOutput` to `true` in your Astro config, and set `output` to `hybrid`.
-         *
-         * ```js
-         * {
-         *  output: 'hybrid',
-         * 	experimental: {
-         *		hybridOutput: true,
-         * 	},
-         * }
-         * ```
-         * Then add `export const prerender =  false` to any page or endpoint you want to opt-out of pre-rendering.
-         * ```astro
-         * ---
-         * // pages/contact.astro
-         * export const prerender = false
-         *
-         * if (Astro.request.method === 'POST') {
-         *  // handle form submission
-         * }
-         * ---
-         * <form method="POST">
-         * 	<input type="text" name="name" />
-         * 	<input type="email" name="email" />
-         * 	<button type="submit">Submit</button>
-         * </form>
-         * ```
-         */
-        hybridOutput?: boolean;
+        redirects?: boolean;
     };
     /** @deprecated - Use "integrations" instead. Run Astro to learn more about migrating. */
     renderers?: never;
@@ -1420,6 +1429,7 @@ export interface AstroAdapter {
     args?: any;
 }
 type Body = string;
+export type ValidRedirectStatus = 300 | 301 | 302 | 303 | 304 | 307 | 308;
 interface AstroSharedContext<Props extends Record<string, any> = Record<string, any>> {
     /**
      * The address (usually IP address) of the user. Used with SSR only.
@@ -1448,7 +1458,7 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
     /**
      * Redirect to another page (**SSR Only**).
      */
-    redirect(path: string, status?: 301 | 302 | 303 | 307 | 308): Response;
+    redirect(path: string, status?: ValidRedirectStatus): Response;
     /**
      * Object accessed via Astro middleware
      */
@@ -1631,7 +1641,7 @@ export interface AstroIntegration {
     };
 }
 export type MiddlewareNext<R> = () => Promise<R>;
-export type MiddlewareHandler<R> = (context: APIContext, next: MiddlewareNext<R>) => Promise<R> | Promise<void> | void;
+export type MiddlewareHandler<R> = (context: APIContext, next: MiddlewareNext<R>) => Promise<R> | R | Promise<void> | void;
 export type MiddlewareResponseHandler = MiddlewareHandler<Response>;
 export type MiddlewareEndpointHandler = MiddlewareHandler<Response | EndpointOutput>;
 export type MiddlewareNextResponse = MiddlewareNext<Response>;
@@ -1642,12 +1652,16 @@ export interface AstroPluginOptions {
     settings: AstroSettings;
     logging: LogOptions;
 }
-export type RouteType = 'page' | 'endpoint';
+export type RouteType = 'page' | 'endpoint' | 'redirect';
 export interface RoutePart {
     content: string;
     dynamic: boolean;
     spread: boolean;
 }
+type RedirectConfig = string | {
+    status: ValidRedirectStatus;
+    destination: string;
+};
 export interface RouteData {
     route: string;
     component: string;
@@ -1659,7 +1673,12 @@ export interface RouteData {
     segments: RoutePart[][];
     type: RouteType;
     prerender: boolean;
+    redirect?: RedirectConfig;
+    redirectRoute?: RouteData;
 }
+export type RedirectRouteData = RouteData & {
+    redirect: string;
+};
 export type SerializedRouteData = Omit<RouteData, 'generate' | 'pattern'> & {
     generate: undefined;
     pattern: string;

package/dist/assets/generate.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import { basename, join } from "node:path/posix";
 import { warn } from "../core/logger/core.js";
 import { prependForwardSlash } from "../core/path.js";
-import { isHybridOutput } from "../prerender/utils.js";
+import { isServerLikeOutput } from "../prerender/utils.js";
 import { getConfiguredImageService, isESMImportedImage } from "./internal.js";
 async function generateImage(buildOpts, options, filepath) {
   if (!isESMImportedImage(options.src)) {
@@ -21,7 +21,7 @@ async function generateImage(buildOpts, options, filepath) {
     useCache = false;
   }
   let serverRoot, clientRoot;
-  if (buildOpts.settings.config.output === "server" || isHybridOutput(buildOpts.settings.config)) {
+  if (isServerLikeOutput(buildOpts.settings.config)) {
     serverRoot = buildOpts.settings.config.build.server;
     clientRoot = buildOpts.settings.config.build.client;
   } else {

package/dist/core/app/index.js

@@ -5,6 +5,7 @@ import { consoleLogDestination } from "../logger/console.js";
 import { error } from "../logger/core.js";
 import { callMiddleware } from "../middleware/callMiddleware.js";
 import { prependForwardSlash, removeTrailingForwardSlash } from "../path.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
 import {
   createEnvironment,
   createRenderContext,
@@ -113,19 +114,17 @@ class App {
     if (routeData.route === "/404") {
       defaultStatus = 404;
     }
-    let page = await this.#manifest.pageMap.get(routeData.component)();
-    let mod = await page.page();
-    if (routeData.type === "page") {
+    let mod = await this.#getModuleForRoute(routeData);
+    if (routeData.type === "page" || routeData.type === "redirect") {
       let response = await this.#renderPage(request, routeData, mod, defaultStatus);
       if (response.status === 500 || response.status === 404) {
-        const errorPageData = matchRoute("/" + response.status, this.#manifestData);
-        if (errorPageData && errorPageData.route !== routeData.route) {
-          page = await this.#manifest.pageMap.get(errorPageData.component)();
-          mod = await page.page();
+        const errorRouteData = matchRoute("/" + response.status, this.#manifestData);
+        if (errorRouteData && errorRouteData.route !== routeData.route) {
+          mod = await this.#getModuleForRoute(errorRouteData);
           try {
             let errorResponse = await this.#renderPage(
               request,
-              errorPageData,
+              errorRouteData,
               mod,
               response.status
             );
@@ -144,7 +143,21 @@ class App {
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }
-  async #renderPage(request, routeData, mod, status = 200) {
+  async #getModuleForRoute(route) {
+    if (route.type === "redirect") {
+      return RedirectSinglePageBuiltModule;
+    } else {
+      const importComponentInstance = this.#manifest.pageMap.get(route.component);
+      if (!importComponentInstance) {
+        throw new Error(
+          `Unexpectedly unable to find a component instance for route ${route.route}`
+        );
+      }
+      const built = await importComponentInstance();
+      return built;
+    }
+  }
+  async #renderPage(request, routeData, page, status = 200) {
     var _a;
     const url = new URL(request.url);
     const pathname = prependForwardSlash(this.removeBase(url.pathname));
@@ -165,6 +178,7 @@ class App {
       }
     }
     try {
+      const mod = await page.page();
       const renderContext = await createRenderContext({
         request,
         origin: url.origin,
@@ -185,7 +199,7 @@ class App {
         site: this.#env.site,
         adapterName: this.#env.adapterName
       });
-      const onRequest = (_a = this.#manifest.middleware) == null ? void 0 : _a.onRequest;
+      const onRequest = (_a = page.middleware) == null ? void 0 : _a.onRequest;
       let response;
       if (onRequest) {
         response = await callMiddleware(
@@ -214,9 +228,10 @@ class App {
       });
     }
   }
-  async #callEndpoint(request, routeData, mod, status = 200) {
+  async #callEndpoint(request, routeData, page, status = 200) {
     const url = new URL(request.url);
     const pathname = "/" + this.removeBase(url.pathname);
+    const mod = await page.page();
     const handler = mod;
     const ctx = await createRenderContext({
       request,
@@ -227,13 +242,7 @@ class App {
       env: this.#env,
       mod: handler
     });
-    const result = await callEndpoint(
-      handler,
-      this.#env,
-      ctx,
-      this.#logging,
-      this.#manifest.middleware
-    );
+    const result = await callEndpoint(handler, this.#env, ctx, this.#logging, page.middleware);
     if (result.type === "response") {
       if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
         const fourOhFourRequest = new Request(new URL("/404", request.url));

package/dist/core/app/types.d.ts

@@ -1,5 +1,5 @@
 import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
-import type { AstroMiddlewareInstance, RouteData, SerializedRouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../@types/astro';
+import type { RouteData, SerializedRouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../@types/astro';
 import type { SinglePageBuiltModule } from '../build/types';
 export type ComponentPath = string;
 export type StylesheetAsset = {
@@ -42,7 +42,6 @@ export interface SSRManifest {
     entryModules: Record<string, string>;
     assets: Set<string>;
     componentMetadata: SSRResult['componentMetadata'];
-    middleware?: AstroMiddlewareInstance<unknown>;
 }
 export type SerializedSSRManifest = Omit<SSRManifest, 'routes' | 'assets' | 'componentMetadata' | 'clientDirectives'> & {
     routes: SerializedRouteInfo[];

package/dist/core/build/common.js

@@ -16,6 +16,7 @@ function getOutFolder(astroConfig, pathname, routeType) {
     case "endpoint":
       return new URL("." + appendForwardSlash(npath.dirname(pathname)), outRoot);
     case "page":
+    case "redirect":
       switch (astroConfig.build.format) {
         case "directory": {
           if (STATUS_CODE_PAGES.has(pathname)) {
@@ -35,6 +36,7 @@ function getOutFile(astroConfig, outFolder, pathname, routeType) {
     case "endpoint":
       return new URL(npath.basename(pathname), outFolder);
     case "page":
+    case "redirect":
       switch (astroConfig.build.format) {
         case "directory": {
           if (STATUS_CODE_PAGES.has(pathname)) {

package/dist/core/build/generate.js

@@ -8,6 +8,7 @@ import {
 } from "../../assets/generate.js";
 import {
   eachPageDataFromEntryPoint,
+  eachRedirectPageData,
   hasPrerenderedPages
 } from "../../core/build/internal.js";
 import {
@@ -16,12 +17,17 @@ import {
   removeTrailingForwardSlash
 } from "../../core/path.js";
 import { runHookBuildGenerated } from "../../integrations/index.js";
-import { isHybridOutput } from "../../prerender/utils.js";
+import { isServerLikeOutput } from "../../prerender/utils.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { callEndpoint, createAPIContext, throwIfRedirectNotAllowed } from "../endpoint/index.js";
 import { AstroError } from "../errors/index.js";
 import { debug, info } from "../logger/core.js";
 import { callMiddleware } from "../middleware/callMiddleware.js";
+import {
+  getRedirectLocationOrThrow,
+  RedirectSinglePageBuiltModule,
+  routeIsRedirect
+} from "../redirects/index.js";
 import { createEnvironment, createRenderContext, renderPage } from "../render/index.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
 import {
@@ -33,8 +39,30 @@ import { createRequest } from "../request.js";
 import { matchRoute } from "../routing/match.js";
 import { getOutputFilename } from "../util.js";
 import { getOutDirWithinCwd, getOutFile, getOutFolder } from "./common.js";
-import { cssOrder, getPageDataByComponent, mergeInlineCss } from "./internal.js";
+import {
+  cssOrder,
+  getEntryFilePathFromComponentPath,
+  getPageDataByComponent,
+  mergeInlineCss
+} from "./internal.js";
 import { getTimeStat } from "./util.js";
+function createEntryURL(filePath, outFolder) {
+  return new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
+}
+async function getEntryForRedirectRoute(route, internals, outFolder) {
+  if (route.type !== "redirect") {
+    throw new Error(`Expected a redirect route.`);
+  }
+  if (route.redirectRoute) {
+    const filePath = getEntryFilePathFromComponentPath(internals, route.redirectRoute.component);
+    if (filePath) {
+      const url = createEntryURL(filePath, outFolder);
+      const ssrEntryPage = await import(url.toString());
+      return ssrEntryPage;
+    }
+  }
+  return RedirectSinglePageBuiltModule;
+}
 function shouldSkipDraft(pageModule, settings) {
   var _a;
   return (
@@ -61,7 +89,7 @@ function chunkIsPage(settings, output, internals) {
 }
 async function generatePages(opts, internals) {
   const timer = performance.now();
-  const ssr = opts.settings.config.output === "server" || isHybridOutput(opts.settings.config);
+  const ssr = isServerLikeOutput(opts.settings.config);
   const serverEntry = opts.buildConfig.serverEntry;
   const outFolder = ssr ? opts.buildConfig.server : getOutDirWithinCwd(opts.settings.config.outDir);
   if (ssr && !hasPrerenderedPages(internals))
@@ -73,17 +101,25 @@ ${bgGreen(black(` ${verb} static routes `))}`);
   if (ssr) {
     for (const [pageData, filePath] of eachPageDataFromEntryPoint(internals)) {
       if (pageData.route.prerender) {
-        const ssrEntryURLPage = new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
+        const ssrEntryURLPage = createEntryURL(filePath, outFolder);
         const ssrEntryPage = await import(ssrEntryURLPage.toString());
         await generatePage(opts, internals, pageData, ssrEntryPage, builtPaths);
       }
     }
+    for (const pageData of eachRedirectPageData(internals)) {
+      const entry = await getEntryForRedirectRoute(pageData.route, internals, outFolder);
+      await generatePage(opts, internals, pageData, entry, builtPaths);
+    }
   } else {
     for (const [pageData, filePath] of eachPageDataFromEntryPoint(internals)) {
-      const ssrEntryURLPage = new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
+      const ssrEntryURLPage = createEntryURL(filePath, outFolder);
       const ssrEntryPage = await import(ssrEntryURLPage.toString());
       await generatePage(opts, internals, pageData, ssrEntryPage, builtPaths);
     }
+    for (const pageData of eachRedirectPageData(internals)) {
+      const entry = await getEntryForRedirectRoute(pageData.route, internals, outFolder);
+      await generatePage(opts, internals, pageData, entry, builtPaths);
+    }
   }
   if (opts.settings.config.experimental.assets) {
     info(opts.logging, null, `
@@ -114,6 +150,9 @@ async function generateImage(opts, transform, path) {
   info(opts.logging, null, `  ${green("\u25B6")} ${path} ${dim(statsText)} ${dim(timeIncrease)}`);
 }
 async function generatePage(opts, internals, pageData, ssrEntry, builtPaths) {
+  if (routeIsRedirect(pageData.route) && !opts.settings.config.experimental.redirects) {
+    throw new Error(`To use redirects first set experimental.redirects to \`true\``);
+  }
   let timeStart = performance.now();
   const renderers = ssrEntry.renderers;
   const pageInfo = getPageDataByComponent(internals, pageData.route.component);
@@ -167,7 +206,7 @@ async function getPathsForRoute(pageData, mod, opts, builtPaths) {
       route: pageData.route,
       isValidate: false,
       logging: opts.logging,
-      ssr: opts.settings.config.output === "server" || isHybridOutput(opts.settings.config)
+      ssr: isServerLikeOutput(opts.settings.config)
     }).then((_result) => {
       const label = _result.staticPaths.length === 1 ? "page" : "pages";
       debug(
@@ -281,7 +320,7 @@ async function generatePath(pathname, opts, gopts, middleware) {
       });
     }
   }
-  const ssr = settings.config.output === "server" || isHybridOutput(settings.config);
+  const ssr = isServerLikeOutput(settings.config);
   const url = getUrlForPath(
     pathname,
     opts.settings.config.base,
@@ -365,11 +404,23 @@ async function generatePath(pathname, opts, gopts, middleware) {
           onRequest,
           apiContext,
           () => {
-            return renderPage({ mod, renderContext, env, apiContext });
+            return renderPage({
+              mod,
+              renderContext,
+              env,
+              apiContext,
+              isCompressHTML: settings.config.compressHTML
+            });
           }
         );
       } else {
-        response = await renderPage({ mod, renderContext, env, apiContext });
+        response = await renderPage({
+          mod,
+          renderContext,
+          env,
+          apiContext,
+          isCompressHTML: settings.config.compressHTML
+        });
       }
     } catch (err) {
       if (!AstroError.is(err) && !err.id && typeof err === "object") {
@@ -377,10 +428,22 @@ async function generatePath(pathname, opts, gopts, middleware) {
       }
       throw err;
     }
-    throwIfRedirectNotAllowed(response, opts.settings.config);
-    if (!response.body)
-      return;
-    body = await response.text();
+    if (response.status >= 300 && response.status < 400) {
+      if (!opts.settings.config.build.redirects) {
+        return;
+      }
+      const location = getRedirectLocationOrThrow(response.headers);
+      body = `<!doctype html>
+<title>Redirecting to: ${location}</title>
+<meta http-equiv="refresh" content="0;url=${location}" />`;
+      if (pageData.route.type !== "redirect") {
+        pageData.route.redirect = location;
+      }
+    } else {
+      if (!response.body)
+        return;
+      body = await response.text();
+    }
   }
   const outFolder = getOutFolder(settings.config, pathname, pageData.route.type);
   const outFile = getOutFile(settings.config, outFolder, pathname, pageData.route.type);

package/dist/core/build/internal.d.ts

@@ -79,6 +79,7 @@ export declare function getPageDataByComponent(internals: BuildInternals, compon
 export declare function getPageDataByViteID(internals: BuildInternals, viteid: ViteID): PageBuildData | undefined;
 export declare function hasPageDataByViteID(internals: BuildInternals, viteid: ViteID): boolean;
 export declare function eachPageData(internals: BuildInternals): Generator<PageBuildData, void, undefined>;
+export declare function eachRedirectPageData(internals: BuildInternals): Generator<PageBuildData, void, unknown>;
 export declare function eachPageDataFromEntryPoint(internals: BuildInternals): Generator<[PageBuildData, string]>;
 export declare function hasPrerenderedPages(internals: BuildInternals): boolean;
 interface OrderInfo {
@@ -95,4 +96,5 @@ export declare function cssOrder(a: OrderInfo, b: OrderInfo): 1 | -1;
 export declare function mergeInlineCss(acc: Array<StylesheetAsset>, current: StylesheetAsset): Array<StylesheetAsset>;
 export declare function isHoistedScript(internals: BuildInternals, id: string): boolean;
 export declare function getPageDatasByHoistedScriptId(internals: BuildInternals, id: string): Generator<PageBuildData, void, unknown>;
+export declare function getEntryFilePathFromComponentPath(internals: BuildInternals, path: string): string | undefined;
 export {};

package/dist/core/build/internal.js

@@ -1,6 +1,10 @@
 import { prependForwardSlash, removeFileExtension } from "../path.js";
 import { viteID } from "../util.js";
-import { ASTRO_PAGE_EXTENSION_POST_PATTERN, ASTRO_PAGE_MODULE_ID } from "./plugins/plugin-pages.js";
+import {
+  ASTRO_PAGE_EXTENSION_POST_PATTERN,
+  ASTRO_PAGE_MODULE_ID,
+  getVirtualModulePageIdFromPath
+} from "./plugins/plugin-pages.js";
 function createBuildInternals() {
   const hoistedScriptIdToHoistedMap = /* @__PURE__ */ new Map();
   const hoistedScriptIdToPagesMap = /* @__PURE__ */ new Map();
@@ -83,6 +87,13 @@ function hasPageDataByViteID(internals, viteid) {
 function* eachPageData(internals) {
   yield* internals.pagesByComponent.values();
 }
+function* eachRedirectPageData(internals) {
+  for (const pageData of eachPageData(internals)) {
+    if (pageData.route.type === "redirect") {
+      yield pageData;
+    }
+  }
+}
 function* eachPageDataFromEntryPoint(internals) {
   for (const [entryPoint, filePath] of internals.entrySpecifierToBundleMap) {
     if (entryPoint.includes(ASTRO_PAGE_MODULE_ID)) {
@@ -153,11 +164,17 @@ function* getPageDatasByHoistedScriptId(internals, id) {
     }
   }
 }
+function getEntryFilePathFromComponentPath(internals, path) {
+  const id = getVirtualModulePageIdFromPath(path);
+  return internals.entrySpecifierToBundleMap.get(id);
+}
 export {
   createBuildInternals,
   cssOrder,
   eachPageData,
   eachPageDataFromEntryPoint,
+  eachRedirectPageData,
+  getEntryFilePathFromComponentPath,
   getPageDataByComponent,
   getPageDataByViteID,
   getPageDatasByChunk,

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

@@ -146,7 +146,7 @@ function rollupPluginAstroBuildCSS(options) {
     enforce: "post",
     async generateBundle(_outputOptions, bundle) {
       var _a;
-      const inlineConfig = settings.config.experimental.inlineStylesheets;
+      const inlineConfig = settings.config.build.inlineStylesheets;
       const { assetsInlineLimit = 4096 } = ((_a = settings.config.vite) == null ? void 0 : _a.build) ?? {};
       Object.entries(bundle).forEach(([id, stylesheet]) => {
         var _a2;