astro 7.0.0-alpha.0 → 7.0.0-alpha.2

package/dist/core/logger/core.js

@@ -136,7 +136,7 @@ class AstroLogger {
     }
   }
   /**
-   * It calls the `flush` function of the provided destinatin, if it exists.
+   * It calls the `flush` function of the provided destination, if it exists.
    */
   flush() {
     if (this.options.destination.flush) {
@@ -169,6 +169,22 @@ class AstroIntegrationLogger {
   debug(message) {
     debug(this.label, message);
   }
+  /**
+   * It calls the `flush` function of the provided destination, if it exists.
+   */
+  flush() {
+    if (this.options.destination.flush) {
+      this.options.destination.flush();
+    }
+  }
+  /**
+   * It calls the `close` function of the provided destination, if it exists.
+   */
+  close() {
+    if (this.options.destination.close) {
+      this.options.destination.close();
+    }
+  }
 }
 export {
   AstroIntegrationLogger,

package/dist/core/messages/runtime.d.ts

@@ -41,9 +41,6 @@ export declare function preferenceReset(name: string): string;
 export declare function telemetryDisabled(): string;
 export declare function telemetryReset(): string;
 export declare function fsStrictWarning(): string;
-export declare function vite8Warning({ viteVersion }: {
-    viteVersion: string;
-}): string;
 export declare function prerelease({ currentVersion }: {
     currentVersion: string;
 }): string;

package/dist/core/messages/runtime.js

@@ -134,13 +134,6 @@ function fsStrictWarning() {
 ${subtitle}
 `;
 }
-function vite8Warning({ viteVersion }) {
-  const title = yellow(`\u25B6 Vite ${bold(viteVersion)} detected in your project.`);
-  const subtitle = `  Astro requires Vite 7. Add ${bold('"overrides": { "vite": "^7" }')} to your ${bold("package.json")} to avoid issues.`;
-  return `${title}
-${subtitle}
-`;
-}
 function prerelease({ currentVersion }) {
   const tag = currentVersion.split("-").slice(1).join("-").replace(/\..*$/, "") || "unknown";
   const badge = bgYellow(black(` ${tag} `));
@@ -276,7 +269,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.0.0-alpha.0"}`
+        `v${"7.0.0-alpha.2"}`
       )} ${headline}`
     );
   }
@@ -334,6 +327,5 @@ export {
   telemetryEnabled,
   telemetryNotice,
   telemetryReset,
-  vite8Warning,
   warnIfCspWithShiki
 };

package/dist/core/middleware/astro-middleware.d.ts

@@ -0,0 +1,27 @@
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { APIContext } from '../../types/public/context.js';
+import { type Pipeline } from '../base-pipeline.js';
+/**
+ * Callback invoked at the bottom of the middleware chain to dispatch the
+ * request to the matched route (endpoint / redirect / page / fallback).
+ *
+ * Callers of `AstroMiddleware.handle` pass their owned `PagesHandler`'s
+ * `handle` method (bound) so route dispatch logic stays out of the
+ * middleware layer.
+ */
+export type RenderRouteCallback = (state: FetchState, ctx: APIContext) => Promise<Response>;
+/**
+ * Handles the execution of Astro's middleware chain (internal + user) for a
+ * single render. Holds a reference to the `Pipeline` and composes the
+ * internal and user middleware at render time.
+ *
+ * Reads per-request data (componentInstance, slots, props, API contexts)
+ * off the supplied `FetchState`. The actual route dispatch (endpoint /
+ * redirect / page / fallback) is supplied by the caller as
+ * `renderRouteCallback` — typically bound to a `PagesHandler.handle`.
+ */
+export declare class AstroMiddleware {
+    #private;
+    constructor(pipeline: Pipeline);
+    handle(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
+}

package/dist/core/middleware/astro-middleware.js

@@ -0,0 +1,51 @@
+import { PipelineFeatures } from "../base-pipeline.js";
+import { attachCookiesToResponse } from "../cookies/index.js";
+import { applyRewriteToState } from "../rewrites/handler.js";
+import { callMiddleware } from "./callMiddleware.js";
+import { sequence } from "./index.js";
+class AstroMiddleware {
+  #pipeline;
+  constructor(pipeline) {
+    this.#pipeline = pipeline;
+  }
+  async handle(state, renderRouteCallback) {
+    state.pipeline.usedFeatures |= PipelineFeatures.middleware;
+    const pipeline = this.#pipeline;
+    await state.getProps();
+    const apiContext = state.getAPIContext();
+    state.counter++;
+    if (state.counter === 4) {
+      return new Response("Loop Detected", {
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/508
+        status: 508,
+        statusText: "Astro detected a loop where you tried to call the rewriting logic more than four times."
+      });
+    }
+    const next = async (ctx, payload) => {
+      if (payload) {
+        pipeline.logger.debug("router", "Called rewriting to:", payload);
+        const result = await pipeline.tryRewrite(payload, state.request);
+        applyRewriteToState(state, payload, result);
+      }
+      return renderRouteCallback(state, ctx);
+    };
+    let response;
+    if (state.skipMiddleware) {
+      response = await next(apiContext);
+    } else {
+      const pipelineMiddleware = await pipeline.getMiddleware();
+      const composed = sequence(...pipeline.internalMiddleware, pipelineMiddleware);
+      response = await callMiddleware(composed, apiContext, next);
+    }
+    response = this.#finalize(state, response);
+    state.response = response;
+    return response;
+  }
+  #finalize(state, response) {
+    attachCookiesToResponse(response, state.cookies);
+    return response;
+  }
+}
+export {
+  AstroMiddleware
+};

package/dist/core/module-loader/vite.js

@@ -3,7 +3,6 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { collectErrorMetadata } from "../errors/dev/utils.js";
 import { getViteErrorPayload } from "../errors/dev/vite.js";
-import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 function createViteLoader(viteServer, ssrEnvironment) {
   const events = new EventEmitter();
   let isTsconfigUpdated = false;
@@ -90,7 +89,7 @@ function createViteLoader(viteServer, ssrEnvironment) {
       return viteServer.environments.client.hot.send(msg);
     },
     getSSREnvironment() {
-      return viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      return ssrEnvironment;
     },
     isHttps() {
       return !!ssrEnvironment.config.server.https;

package/dist/core/pages/handler.d.ts

@@ -0,0 +1,20 @@
+import type { APIContext } from '../../types/public/context.js';
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { Pipeline } from '../base-pipeline.js';
+/**
+ * Handles dispatch of a matched route (endpoint / redirect / page / fallback)
+ * at the bottom of the middleware chain. This is a pure dispatch layer — it
+ * renders whatever route the `FetchState` currently points to without any
+ * rewrite logic. Rewrites are handled upstream: `Rewrites.execute()` for
+ * `Astro.rewrite()` and `AstroMiddleware` for `next(payload)`.
+ *
+ * `PagesHandler` is the `next` callback that `AstroMiddleware` invokes at
+ * the end of the middleware chain. `AstroHandler` owns a single instance
+ * and passes its `handle` method as the callback. Error handlers and the
+ * container also use `PagesHandler` directly for the same dispatch behavior.
+ */
+export declare class PagesHandler {
+    #private;
+    constructor(pipeline: Pipeline);
+    handle(state: FetchState, ctx: APIContext): Promise<Response>;
+}

package/dist/core/pages/handler.js

@@ -0,0 +1,75 @@
+import { renderEndpoint } from "../../runtime/server/endpoint.js";
+import { renderPage } from "../../runtime/server/index.js";
+import {
+  ASTRO_ERROR_HEADER,
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY,
+  REWRITE_DIRECTIVE_HEADER_VALUE,
+  ROUTE_TYPE_HEADER
+} from "../constants.js";
+import { getCookiesFromResponse } from "../cookies/response.js";
+const EMPTY_SLOTS = Object.freeze({});
+class PagesHandler {
+  #pipeline;
+  constructor(pipeline) {
+    this.#pipeline = pipeline;
+  }
+  async handle(state, ctx) {
+    const pipeline = this.#pipeline;
+    const { logger, streaming } = pipeline;
+    let response;
+    const componentInstance = await state.loadComponentInstance();
+    switch (state.routeData.type) {
+      case "endpoint": {
+        response = await renderEndpoint(
+          componentInstance,
+          ctx,
+          state.routeData.prerender,
+          logger
+        );
+        break;
+      }
+      case "page": {
+        const props = await state.getProps();
+        const actionApiContext = state.getActionAPIContext();
+        const result = await state.createResult(componentInstance, actionApiContext);
+        try {
+          response = await renderPage(
+            result,
+            componentInstance?.default,
+            props,
+            state.slots ?? EMPTY_SLOTS,
+            streaming,
+            state.routeData
+          );
+        } catch (e) {
+          result.cancelled = true;
+          throw e;
+        }
+        response.headers.set(ROUTE_TYPE_HEADER, "page");
+        if (state.routeData.route === "/404" || state.routeData.route === "/500") {
+          response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
+        }
+        if (state.isRewriting) {
+          response.headers.set(REWRITE_DIRECTIVE_HEADER_KEY, REWRITE_DIRECTIVE_HEADER_VALUE);
+        }
+        break;
+      }
+      case "redirect": {
+        return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
+      }
+      case "fallback": {
+        return new Response(null, { status: 500, headers: { [ROUTE_TYPE_HEADER]: "fallback" } });
+      }
+    }
+    const responseCookies = getCookiesFromResponse(response);
+    if (responseCookies) {
+      state.cookies.merge(responseCookies);
+    }
+    state.response = response;
+    return response;
+  }
+}
+export {
+  PagesHandler
+};

package/dist/core/preview/index.js

@@ -9,7 +9,7 @@ import { resolveConfig } from "../config/config.js";
 import { loadOrCreateNodeLogger } from "../logger/load.js";
 import { createSettings } from "../config/settings.js";
 import { createRoutesList } from "../routing/create-manifest.js";
-import { getPrerenderDefault } from "../../prerender/utils.js";
+import { getClientOutputDirectory, getPrerenderDefault } from "../../prerender/utils.js";
 import { ensureProcessNodeEnv } from "../util.js";
 import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
@@ -28,12 +28,13 @@ async function preview(inlineConfig) {
     command: "preview",
     logger
   });
-  await createRoutesList({ settings, cwd: inlineConfig.root }, logger);
   settings.buildOutput = getPrerenderDefault(settings.config) ? "static" : "server";
+  await createRoutesList({ settings, cwd: inlineConfig.root }, logger);
   await runHookConfigDone({ settings, logger, command: "preview" });
-  if (settings.buildOutput === "static") {
-    if (!fs.existsSync(settings.config.outDir)) {
-      const outDirPath = fileURLToPath(settings.config.outDir);
+  if (settings.buildOutput === "static" && !settings.adapter?.previewEntrypoint) {
+    const clientOutDir = getClientOutputDirectory(settings);
+    if (!fs.existsSync(clientOutDir)) {
+      const outDirPath = fileURLToPath(clientOutDir);
       throw new Error(
         `[preview] The output directory ${outDirPath} does not exist. Did you run \`astro build\`?`
       );

package/dist/core/preview/static-preview-server.js

@@ -1,6 +1,7 @@
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
 import { mergeConfig, preview } from "vite";
+import { getClientOutputDirectory } from "../../prerender/utils.js";
 import * as msg from "../messages/runtime.js";
 import { getResolvedHostForHttpServer } from "./util.js";
 import { vitePluginAstroPreview } from "./vite-plugin-astro-preview.js";
@@ -15,7 +16,7 @@ async function createStaticPreviewServer(settings, logger) {
       base: settings.config.base,
       appType: "mpa",
       build: {
-        outDir: fileURLToPath(settings.config.outDir)
+        outDir: fileURLToPath(getClientOutputDirectory(settings))
       },
       root: fileURLToPath(settings.config.root),
       preview: {
@@ -67,9 +68,11 @@ async function createStaticPreviewServer(settings, logger) {
       previewServer.httpServer.addListener("error", reject);
     });
   }
+  const address = previewServer.httpServer.address();
+  const actualPort = address && typeof address === "object" ? address.port : settings.config.server.port;
   return {
     host: getResolvedHostForHttpServer(settings.config.server.host),
-    port: settings.config.server.port,
+    port: actualPort,
     closed,
     server: previewServer.httpServer,
     stop: previewServer.close.bind(previewServer)

package/dist/core/redirects/render.d.ts

@@ -1,7 +1,7 @@
 import type { Params } from '../../types/public/common.js';
 import type { RedirectConfig } from '../../types/public/index.js';
 import type { RouteData } from '../../types/public/internal.js';
-import type { RenderContext } from '../render-context.js';
+import type { FetchState } from '../fetch/fetch-state.js';
 export declare function redirectIsExternal(redirect: RedirectConfig): boolean;
 /**
  * Computes the HTTP status code for a redirect response.
@@ -18,4 +18,4 @@ export declare function computeRedirectStatus(method: string, redirect: Redirect
  * are substituted manually into the string redirect target.
  */
 export declare function resolveRedirectTarget(params: Params, redirect: RedirectConfig | undefined, redirectRoute: RouteData | undefined, trailingSlash: 'always' | 'never' | 'ignore'): string;
-export declare function renderRedirect(renderContext: RenderContext): Promise<Response>;
+export declare function renderRedirect(state: FetchState): Promise<Response>;

package/dist/core/redirects/render.js

@@ -1,3 +1,4 @@
+import { PipelineFeatures } from "../base-pipeline.js";
 import { getRouteGenerator } from "../routing/generator.js";
 function isExternalURL(url) {
   return url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//");
@@ -32,20 +33,18 @@ function resolveRedirectTarget(params, redirect, redirectRoute, trailingSlash) {
   }
   return redirect.destination;
 }
-async function renderRedirect(renderContext) {
-  const {
-    request: { method },
-    routeData
-  } = renderContext;
+async function renderRedirect(state) {
+  state.pipeline.usedFeatures |= PipelineFeatures.redirects;
+  const routeData = state.routeData;
   const { redirect, redirectRoute } = routeData;
-  const status = computeRedirectStatus(method, redirect, redirectRoute);
+  const status = computeRedirectStatus(state.request.method, redirect, redirectRoute);
   const headers = {
     location: encodeURI(
       resolveRedirectTarget(
-        renderContext.params,
+        state.params,
         redirect,
         redirectRoute,
-        renderContext.pipeline.manifest.trailingSlash
+        state.pipeline.manifest.trailingSlash
       )
     )
   };

package/dist/core/render/params-and-props.js

@@ -29,7 +29,7 @@ async function getProps(opts) {
   });
   const params = getParams(route, pathname);
   const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger, trailingSlash);
-  if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
+  if (!matchedStaticPath && route.origin !== "internal" && (serverLike ? route.prerender : true)) {
     throw new AstroError({
       ...AstroErrorData.NoMatchingStaticPathFound,
       message: AstroErrorData.NoMatchingStaticPathFound.message(pathname),
@@ -44,7 +44,7 @@ async function getProps(opts) {
 }
 function getParams(route, pathname) {
   if (!route.params.length) return {};
-  const path = pathname.endsWith(".html") && !routeHasHtmlExtension(route) ? pathname.slice(0, -5) : pathname;
+  const path = pathname.endsWith(".html") && route.type === "page" && !routeHasHtmlExtension(route) ? pathname.slice(0, -5) : pathname;
   const allPatterns = [route, ...route.fallbackRoutes].map((r) => r.pattern);
   const paramsMatch = allPatterns.map((pattern) => pattern.exec(path)).find((x) => x);
   if (!paramsMatch) return {};

package/dist/core/render/route-cache.d.ts

@@ -13,6 +13,7 @@ interface CallGetStaticPathsOptions {
 }
 export declare function callGetStaticPaths({ mod, route, routeCache, ssr, base, trailingSlash, }: CallGetStaticPathsOptions): Promise<GetStaticPathsResultKeyed>;
 interface RouteCacheEntry {
+    mod: ComponentInstance;
     staticPaths: GetStaticPathsResultKeyed;
 }
 /**

package/dist/core/render/route-cache.js

@@ -13,13 +13,13 @@ async function callGetStaticPaths({
   if (!mod) {
     throw new Error("This is an error caused by Astro and not your code. Please file an issue.");
   }
-  if (cached?.staticPaths) {
+  if (cached?.staticPaths && cached.mod === mod) {
     return cached.staticPaths;
   }
   validateDynamicRouteModule(mod, { ssr, route });
-  if (ssr && !route.prerender) {
+  if (ssr && !route.prerender || route.origin === "internal") {
     const entry = Object.assign([], { keyed: /* @__PURE__ */ new Map() });
-    routeCache.set(route, { ...cached, staticPaths: entry });
+    routeCache.set(route, { ...cached, mod, staticPaths: entry });
     return entry;
   }
   let staticPaths = [];
@@ -39,7 +39,7 @@ async function callGetStaticPaths({
     const paramsKey = stringifyParams(sp.params, route, trailingSlash);
     keyedStaticPaths.keyed.set(paramsKey, sp);
   }
-  routeCache.set(route, { ...cached, staticPaths: keyedStaticPaths });
+  routeCache.set(route, { ...cached, mod, staticPaths: keyedStaticPaths });
   return keyedStaticPaths;
 }
 class RouteCache {

package/dist/core/render/slots.js

@@ -1,13 +1,20 @@
 import { renderSlotToString } from "../../runtime/server/index.js";
 import { renderJSX } from "../../runtime/server/jsx.js";
+import { isRenderTemplateResult } from "../../runtime/server/render/astro/index.js";
 import { chunkToString } from "../../runtime/server/render/index.js";
 import { isRenderInstruction } from "../../runtime/server/render/instruction.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 function getFunctionExpression(slot) {
   if (!slot) return;
-  const expressions = slot?.expressions?.filter((e) => isRenderInstruction(e) === false);
+  const expressions = slot?.expressions?.filter(
+    (e) => isRenderInstruction(e) === false || isRenderTemplateResult(e)
+  );
   if (expressions?.length !== 1) return;
-  return expressions[0];
+  const expression = expressions[0];
+  if (isRenderTemplateResult(expression)) {
+    return getFunctionExpression(expression);
+  }
+  return expression;
 }
 class Slots {
   #result;

package/dist/core/rewrites/handler.d.ts

@@ -0,0 +1,37 @@
+import type { ComponentInstance } from '../../types/astro.js';
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { RewritePayload } from '../../types/public/common.js';
+import type { RouteData } from '../../types/public/internal.js';
+interface TryRewriteResult {
+    routeData: RouteData;
+    componentInstance: ComponentInstance;
+    newUrl: URL;
+    pathname: string;
+}
+/**
+ * Validates and applies a rewrite target to the given `FetchState`.
+ *
+ * - Validates that SSR→prerender rewrites are not attempted (except
+ *   for i18n fallback routes).
+ * - Mutates `state` to reflect the new route: request, URL, cookies,
+ *   params, pathname, component instance, etc.
+ * - Invalidates cached API contexts so they're re-derived from the
+ *   new route.
+ *
+ * Called by both `Rewrites.execute()` (user-triggered `Astro.rewrite`)
+ * and `AstroMiddleware` (middleware `next(payload)`).
+ */
+export declare function applyRewriteToState(state: FetchState, payload: RewritePayload, { routeData, componentInstance, newUrl, pathname }: TryRewriteResult, { mergeCookies }?: {
+    mergeCookies?: boolean;
+}): void;
+/**
+ * Executes a user-triggered rewrite (`Astro.rewrite(...)` /
+ * `ctx.rewrite(...)`) against a `FetchState`. Resolves the rewrite
+ * target via `pipeline.tryRewrite`, validates it, mutates the
+ * `FetchState` to reflect the new route, and re-runs the middleware
+ * and page dispatch to produce the new response.
+ */
+export declare class Rewrites {
+    execute(state: FetchState, payload: RewritePayload): Promise<Response>;
+}
+export {};

package/dist/core/rewrites/handler.js

@@ -0,0 +1,67 @@
+import { AstroCookies } from "../cookies/index.js";
+import { ForbiddenRewrite } from "../errors/errors-data.js";
+import { AstroError } from "../errors/errors.js";
+import { AstroMiddleware } from "../middleware/astro-middleware.js";
+import { PagesHandler } from "../pages/handler.js";
+import { getParams } from "../render/index.js";
+import { copyRequest, setOriginPathname } from "../routing/rewrite.js";
+import { createNormalizedUrl } from "../util/normalized-url.js";
+function applyRewriteToState(state, payload, { routeData, componentInstance, newUrl, pathname }, { mergeCookies = false } = {}) {
+  const pipeline = state.pipeline;
+  const oldPathname = state.pathname;
+  const isI18nFallback = routeData.fallbackRoutes && routeData.fallbackRoutes.length > 0;
+  if (pipeline.manifest.serverLike && !state.routeData.prerender && routeData.prerender && !isI18nFallback) {
+    throw new AstroError({
+      ...ForbiddenRewrite,
+      message: ForbiddenRewrite.message(state.pathname, pathname, routeData.component),
+      hint: ForbiddenRewrite.hint(routeData.component)
+    });
+  }
+  state.routeData = routeData;
+  state.componentInstance = componentInstance;
+  if (payload instanceof Request) {
+    state.request = payload;
+  } else {
+    state.request = copyRequest(
+      newUrl,
+      state.request,
+      routeData.prerender,
+      pipeline.logger,
+      state.routeData.route
+    );
+  }
+  state.url = createNormalizedUrl(state.request.url);
+  if (mergeCookies) {
+    const newCookies = new AstroCookies(state.request);
+    if (state.cookies) {
+      newCookies.merge(state.cookies);
+    }
+    state.cookies = newCookies;
+  }
+  state.params = getParams(routeData, pathname);
+  state.pathname = pathname;
+  state.isRewriting = true;
+  state.status = 200;
+  setOriginPathname(
+    state.request,
+    oldPathname,
+    pipeline.manifest.trailingSlash,
+    pipeline.manifest.buildFormat
+  );
+  state.invalidateContexts();
+}
+class Rewrites {
+  async execute(state, payload) {
+    const pipeline = state.pipeline;
+    pipeline.logger.debug("router", "Calling rewrite: ", payload);
+    const result = await pipeline.tryRewrite(payload, state.request);
+    applyRewriteToState(state, payload, result, { mergeCookies: true });
+    const middleware = new AstroMiddleware(pipeline);
+    const pagesHandler = new PagesHandler(pipeline);
+    return middleware.handle(state, pagesHandler.handle.bind(pagesHandler));
+  }
+}
+export {
+  Rewrites,
+  applyRewriteToState
+};

package/dist/core/routing/3xx.js

@@ -1,3 +1,4 @@
+import { escape } from "html-escaper";
 function redirectTemplate({
   status,
   absoluteLocation,
@@ -5,13 +6,16 @@ function redirectTemplate({
   from
 }) {
   const delay = status === 302 ? 2 : 0;
+  const rel = escape(String(relativeLocation));
+  const abs = escape(String(absoluteLocation));
+  const fromHtml = from ? `from <code>${escape(from)}</code> ` : "";
   return `<!doctype html>
-<title>Redirecting to: ${relativeLocation}</title>
-<meta http-equiv="refresh" content="${delay};url=${relativeLocation}">
+<title>Redirecting to: ${rel}</title>
+<meta http-equiv="refresh" content="${delay};url=${rel}">
 <meta name="robots" content="noindex">
-<link rel="canonical" href="${absoluteLocation}">
+<link rel="canonical" href="${abs}">
 <body>
-	<a href="${relativeLocation}">Redirecting ${from ? `from <code>${from}</code> ` : ""}to <code>${relativeLocation}</code></a>
+	<a href="${rel}">Redirecting ${fromHtml}to <code>${rel}</code></a>
 </body>`;
 }
 export {

package/dist/core/routing/create-manifest.js

@@ -388,6 +388,16 @@ function createRedirectRoutes({ settings }, routeMap) {
         message: InvalidRedirectDestination.message(from, destination)
       });
     }
+    if (params.length > 0 && redirectRoute && !URL.canParse(destination) && getPrerenderDefault(config)) {
+      const destParams = redirectRoute.params ?? [];
+      const missingParams = params.filter((p) => !destParams.includes(p));
+      if (missingParams.length > 0) {
+        throw new AstroError({
+          ...InvalidRedirectDestination,
+          message: InvalidRedirectDestination.message(from, destination, missingParams)
+        });
+      }
+    }
     routes.push({
       type: "redirect",
       // For backwards compatibility, a redirect is never considered an index route.
@@ -667,7 +677,7 @@ function joinSegments(segments) {
   const arr = segments.map((segment) => {
     return segment.map((rp) => rp.dynamic ? `[${rp.content}]` : rp.content).join("");
   });
-  return `/${arr.join("/")}`.toLowerCase();
+  return `/${arr.join("/")}`;
 }
 function replaceOrKeep(original, from, to) {
   if (original.startsWith(`/${to}/`) || original === `/${to}`) return original;

package/dist/core/routing/handler.d.ts

@@ -0,0 +1,17 @@
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { BaseApp } from '../app/base.js';
+import { type Pipeline } from '../base-pipeline.js';
+export declare class AstroHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    handle(state: FetchState): Promise<Response>;
+    /**
+     * Renders a response for the given `FetchState`. Assumes
+     * trailing-slash redirects and routeData resolution have already run.
+     *
+     * User-triggered rewrites (`Astro.rewrite` / `ctx.rewrite`) go through
+     * `Rewrites.execute` on the current `FetchState` — they mutate the
+     * existing state in place and re-run middleware + page dispatch.
+     */
+    render(state: FetchState): Promise<Response>;
+}