astro 7.2.2 → 7.2.4

package/dist/core/messages/runtime.js

@@ -270,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.2.2"}`
+        `v${"7.2.4"}`
       )} ${headline}`
     );
   }

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

@@ -1,46 +1,36 @@
 import type { FetchState } from '../fetch/fetch-state.js';
 import type { APIContext } from '../../types/public/context.js';
-import type { BaseApp } from '../app/base.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.
+ * Callers of `handleMiddleware` pass `handlePages` (or a wrapper around it)
+ * 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.
+ * Runs Astro's middleware chain (origin check + user `onRequest`) for a
+ * single render, reading the composed middleware from the manifest and
+ * 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 `handlePages`.
+ */
+export declare function handleMiddleware(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
+/**
+ * Like `handleMiddleware`, but mirrors the app-level error handling that
+ * `handleRequest` provides on the standard path, the same way
+ * `handlePagesWithErrorFallback` does for `pages()`. When no route matched
+ * it returns a 404 marked with `X-Astro-Error` for the app's post-check;
+ * when Astro's own middleware chain throws it logs the error and renders
+ * the custom `500.astro`.
+ *
+ * Errors surfaced through `renderRouteCallback` (the host framework's
+ * `next`, e.g. host middleware mounted below `middleware()`) are re-thrown
+ * instead, so the host's own error handling still runs rather than being
+ * swallowed into Astro's 500 page. A sentinel tells the two apart.
  *
- * 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`.
+ * Used by the composable `astro/fetch` `middleware()` entry point, where
+ * there is no surrounding `handleRequest` to supply this fallback.
  */
-export declare class AstroMiddleware {
-    #private;
-    constructor(pipeline: Pipeline);
-    handle(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
-    /**
-     * Like `handle`, but mirrors the app-level error handling that
-     * `AstroHandler` provides on the standard path, the same way
-     * `PagesHandler.handleWithErrorFallback` does for `pages()`. When no
-     * route matched it returns a 404 marked with `X-Astro-Error` for the
-     * app's post-check; when Astro's own middleware chain throws it logs the
-     * error and renders the custom `500.astro`.
-     *
-     * Errors surfaced through `renderRouteCallback` (the host framework's
-     * `next`, e.g. host middleware mounted below `middleware()`) are
-     * re-thrown instead, so the host's own error handling still runs rather
-     * than being swallowed into Astro's 500 page. A sentinel tells the two
-     * apart.
-     *
-     * Used by the composable `astro/fetch` `middleware()` entry point, where
-     * there is no surrounding `AstroHandler` to supply this fallback.
-     */
-    handleWithErrorFallback(app: BaseApp<Pipeline>, state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
-}
+export declare function handleMiddlewareWithErrorFallback(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;

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

@@ -1,94 +1,74 @@
-import { PipelineFeatures } from "../base-pipeline.js";
 import { ASTRO_ERROR_HEADER } from "../constants.js";
 import { attachCookiesToResponse } from "../cookies/index.js";
+import { getEnvironment } from "../environment/index.js";
+import { renderErrorFromState } from "../errors/handler.js";
+import { markFeatureUsed, FetchFeatures } from "../fetch/features.js";
 import { applyRewriteToState } from "../rewrites/handler.js";
 import { callMiddleware } from "./callMiddleware.js";
+import { getMiddleware } from "./load.js";
 import { sequence } from "./index.js";
-class AstroMiddleware {
-  #pipeline;
-  constructor(pipeline) {
-    this.#pipeline = pipeline;
+async function handleMiddleware(state, renderRouteCallback) {
+  markFeatureUsed(state.manifest, FetchFeatures.middleware);
+  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."
+    });
   }
-  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) {
+      state.logger.debug("router", "Called rewriting to:", payload);
+      const result = await getEnvironment(state.manifest).tryRewrite(
+        state.manifest,
+        payload,
+        state.request
+      );
+      applyRewriteToState(state, payload, result);
     }
-    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;
+    return renderRouteCallback(state, ctx);
+  };
+  let response;
+  if (state.skipMiddleware) {
+    response = await next(apiContext);
+  } else {
+    const middleware = await getMiddleware(state.manifest);
+    const composed = sequence(middleware);
+    response = await callMiddleware(composed, apiContext, next);
   }
-  /**
-   * Like `handle`, but mirrors the app-level error handling that
-   * `AstroHandler` provides on the standard path, the same way
-   * `PagesHandler.handleWithErrorFallback` does for `pages()`. When no
-   * route matched it returns a 404 marked with `X-Astro-Error` for the
-   * app's post-check; when Astro's own middleware chain throws it logs the
-   * error and renders the custom `500.astro`.
-   *
-   * Errors surfaced through `renderRouteCallback` (the host framework's
-   * `next`, e.g. host middleware mounted below `middleware()`) are
-   * re-thrown instead, so the host's own error handling still runs rather
-   * than being swallowed into Astro's 500 page. A sentinel tells the two
-   * apart.
-   *
-   * Used by the composable `astro/fetch` `middleware()` entry point, where
-   * there is no surrounding `AstroHandler` to supply this fallback.
-   */
-  async handleWithErrorFallback(app, state, renderRouteCallback) {
-    if (!state.routeData) {
-      return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
-    }
-    let nextError;
-    try {
-      return await this.handle(state, async (s, ctx) => {
-        try {
-          return await renderRouteCallback(s, ctx);
-        } catch (err) {
-          nextError = err;
-          throw err;
-        }
-      });
-    } catch (err) {
-      if (err === nextError) throw err;
-      app.logger.error(null, err.stack || err.message || String(err));
-      return app.renderError(state.request, {
-        ...state.renderOptions,
-        status: 500,
-        error: err,
-        pathname: state.pathname
-      });
-    }
+  attachCookiesToResponse(response, state.cookies);
+  state.response = response;
+  return response;
+}
+async function handleMiddlewareWithErrorFallback(state, renderRouteCallback) {
+  if (!state.routeData) {
+    return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
   }
-  #finalize(state, response) {
-    attachCookiesToResponse(response, state.cookies);
-    return response;
+  let nextError;
+  try {
+    return await handleMiddleware(state, async (s, ctx) => {
+      try {
+        return await renderRouteCallback(s, ctx);
+      } catch (err) {
+        nextError = err;
+        throw err;
+      }
+    });
+  } catch (err) {
+    if (err === nextError) throw err;
+    state.logger.error(null, err.stack || err.message || String(err));
+    return renderErrorFromState(state, state.request, {
+      ...state.renderOptions,
+      status: 500,
+      error: err,
+      pathname: state.pathname
+    });
   }
 }
 export {
-  AstroMiddleware
+  handleMiddleware,
+  handleMiddlewareWithErrorFallback
 };

package/dist/core/middleware/load.d.ts

@@ -0,0 +1,19 @@
+import type { MiddlewareHandler } from '../../types/public/common.js';
+import type { SSRManifest } from '../app/types.js';
+/**
+ * Resolves the middleware from the manifest and returns the `onRequest`
+ * function (prefixed with the origin-check middleware when configured). If
+ * `onRequest` isn't there, it returns a no-op function.
+ */
+export declare function getMiddleware(manifest: SSRManifest): Promise<MiddlewareHandler>;
+/**
+ * The already-resolved middleware for a manifest, or `undefined` when
+ * `getMiddleware` has not settled yet. Sync — used where a synchronous
+ * snapshot is required (the container's `insertRoute`).
+ */
+export declare function peekMiddleware(manifest: SSRManifest): MiddlewareHandler | undefined;
+/**
+ * Clears the cached middleware so it is re-resolved on the next request.
+ * Called via HMR when middleware files change during development.
+ */
+export declare function clearMiddleware(manifest: SSRManifest): void;

package/dist/core/middleware/load.js

@@ -0,0 +1,36 @@
+import { createOriginCheckMiddleware } from "../app/origin-check.js";
+import { createAsyncManifestMemo } from "../manifest/memo.js";
+import { NOOP_MIDDLEWARE_FN } from "./noop-middleware.js";
+import { sequence } from "./sequence.js";
+const resolvedMiddleware = /* @__PURE__ */ new WeakMap();
+const middlewareMemo = createAsyncManifestMemo(async (manifest) => {
+  let handler;
+  if (manifest.middleware) {
+    const middlewareInstance = await manifest.middleware();
+    const onRequest = middlewareInstance.onRequest ?? NOOP_MIDDLEWARE_FN;
+    const internalMiddlewares = [onRequest];
+    if (manifest.checkOrigin) {
+      internalMiddlewares.unshift(createOriginCheckMiddleware());
+    }
+    handler = sequence(...internalMiddlewares);
+  } else {
+    handler = NOOP_MIDDLEWARE_FN;
+  }
+  resolvedMiddleware.set(manifest, handler);
+  return handler;
+});
+function getMiddleware(manifest) {
+  return middlewareMemo.get(manifest);
+}
+function peekMiddleware(manifest) {
+  return resolvedMiddleware.get(manifest);
+}
+function clearMiddleware(manifest) {
+  middlewareMemo.invalidate(manifest);
+  resolvedMiddleware.delete(manifest);
+}
+export {
+  clearMiddleware,
+  getMiddleware,
+  peekMiddleware
+};

package/dist/core/middleware/sequence.js

@@ -1,7 +1,8 @@
-import { pipelineSymbol } from "../constants.js";
+import { fetchStateSymbol } from "../constants.js";
+import { getEnvironment } from "../environment/index.js";
 import { ForbiddenRewrite } from "../errors/errors-data.js";
 import { AstroError } from "../errors/index.js";
-import { getParams } from "../render/index.js";
+import { getParams } from "../render/params-and-props.js";
 import { setOriginPathname } from "../routing/rewrite.js";
 import { defineMiddleware } from "./defineMiddleware.js";
 function sequence(...handlers) {
@@ -32,12 +33,19 @@ function sequence(...handlers) {
               );
             }
             const oldPathname = handleContext.url.pathname;
-            const pipeline = Reflect.get(handleContext, pipelineSymbol);
-            const { routeData, pathname } = await pipeline.tryRewrite(
+            const state = Reflect.get(handleContext, fetchStateSymbol);
+            if (!state) {
+              throw new Error(
+                "FetchState not found on APIContext. `next(payload)` rewrites require a context created through Astro's request pipeline."
+              );
+            }
+            const manifest = state.manifest;
+            const { routeData, pathname } = await getEnvironment(manifest).tryRewrite(
+              manifest,
               payload,
               handleContext.request
             );
-            if (pipeline.manifest.serverLike === true && handleContext.isPrerendered === false && routeData.prerender === true) {
+            if (manifest.serverLike === true && handleContext.isPrerendered === false && routeData.prerender === true) {
               throw new AstroError({
                 ...ForbiddenRewrite,
                 message: ForbiddenRewrite.message(
@@ -56,8 +64,8 @@ function sequence(...handlers) {
             setOriginPathname(
               handleContext.request,
               oldPathname,
-              pipeline.manifest.trailingSlash,
-              pipeline.manifest.buildFormat
+              manifest.trailingSlash,
+              manifest.buildFormat
             );
           }
           return applyHandle(i + 1, handleContext);

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

@@ -1,33 +1,26 @@
 import type { APIContext } from '../../types/public/context.js';
-import type { BaseApp } from '../app/base.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)`.
+ * rewrite logic. Rewrites are handled upstream: `executeRewrite()` for
+ * `Astro.rewrite()` and `handleMiddleware` 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.
+ * `handlePages` is the `next` callback that `handleMiddleware` invokes at
+ * the end of the middleware chain. Error handlers and the container also
+ * use it directly for the same dispatch behavior.
  */
-export declare class PagesHandler {
-    #private;
-    constructor(pipeline: Pipeline);
-    handle(state: FetchState, ctx: APIContext): Promise<Response>;
-    /**
-     * Like `handle`, but mirrors the app-level error handling that
-     * `AstroHandler` provides on the standard path: unmatched routes
-     * return a 404 marked with `X-Astro-Error` for the app's post-check
-     * to render the 404 error page, and render-time errors are logged
-     * and render the 500 error page instead of propagating to the host
-     * framework.
-     *
-     * Used by the composable `astro/fetch` `pages()` entry point, where
-     * there is no surrounding `AstroHandler` to supply this fallback.
-     */
-    handleWithErrorFallback(app: BaseApp<Pipeline>, state: FetchState): Promise<Response>;
-}
+export declare function handlePages(state: FetchState, ctx: APIContext): Promise<Response>;
+/**
+ * Like `handlePages`, but mirrors the app-level error handling that
+ * `handleRequest` provides on the standard path: unmatched routes
+ * return a 404 marked with `X-Astro-Error` for the app's post-check
+ * to render the 404 error page, and render-time errors are logged
+ * and render the 500 error page instead of propagating to the host
+ * framework.
+ *
+ * Used by the composable `astro/fetch` `pages()` entry point, where
+ * there is no surrounding `handleRequest` to supply this fallback.
+ */
+export declare function handlePagesWithErrorFallback(state: FetchState): Promise<Response>;

package/dist/core/pages/handler.js

@@ -6,99 +6,83 @@ import {
   isForbiddenCrossOriginRequest
 } from "../app/origin-check.js";
 import { getCookiesFromResponse } from "../cookies/response.js";
+import { renderErrorFromState } from "../errors/handler.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;
-    state.resetResponseMetadata();
-    let response;
-    const componentInstance = await state.loadComponentInstance();
-    switch (state.routeData.type) {
-      case "endpoint": {
-        response = await renderEndpoint(
-          componentInstance,
-          ctx,
-          state.routeData.prerender,
-          logger,
-          state
+async function handlePages(state, ctx) {
+  const { logger, streaming } = state;
+  state.resetResponseMetadata();
+  let response;
+  const componentInstance = await state.loadComponentInstance();
+  switch (state.routeData.type) {
+    case "endpoint": {
+      response = await renderEndpoint(
+        componentInstance,
+        ctx,
+        state.routeData.prerender,
+        logger,
+        state
+      );
+      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
         );
-        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;
-        }
-        state.responseRouteType = "page";
-        if (state.routeData.route === "/404" || state.routeData.route === "/500") {
-          state.skipErrorReroute = true;
-        }
-        break;
+      } catch (e) {
+        result.cancelled = true;
+        throw e;
       }
-      case "redirect": {
-        return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
+      state.responseRouteType = "page";
+      if (state.routeData.route === "/404" || state.routeData.route === "/500") {
+        state.skipErrorReroute = true;
       }
-      case "fallback": {
-        state.responseRouteType = "fallback";
-        return new Response(null, { status: 500 });
-      }
-    }
-    const responseCookies = getCookiesFromResponse(response);
-    if (responseCookies) {
-      state.cookies.merge(responseCookies);
+      break;
     }
-    state.response = response;
-    return response;
-  }
-  /**
-   * Like `handle`, but mirrors the app-level error handling that
-   * `AstroHandler` provides on the standard path: unmatched routes
-   * return a 404 marked with `X-Astro-Error` for the app's post-check
-   * to render the 404 error page, and render-time errors are logged
-   * and render the 500 error page instead of propagating to the host
-   * framework.
-   *
-   * Used by the composable `astro/fetch` `pages()` entry point, where
-   * there is no surrounding `AstroHandler` to supply this fallback.
-   */
-  async handleWithErrorFallback(app, state) {
-    if (!state.routeData) {
+    case "redirect": {
       return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
     }
-    const ctx = state.getAPIContext();
-    if (this.#pipeline.manifest.checkOrigin && isForbiddenCrossOriginRequest(ctx.request, ctx.url, ctx.isPrerendered)) {
-      return createCrossOriginForbiddenResponse(ctx.request);
-    }
-    try {
-      return await this.handle(state, ctx);
-    } catch (err) {
-      app.logger.error(null, err.stack || err.message || String(err));
-      return app.renderError(state.request, {
-        ...state.renderOptions,
-        status: 500,
-        error: err,
-        pathname: state.pathname
-      });
+    case "fallback": {
+      state.responseRouteType = "fallback";
+      return new Response(null, { status: 500 });
     }
   }
+  const responseCookies = getCookiesFromResponse(response);
+  if (responseCookies) {
+    state.cookies.merge(responseCookies);
+  }
+  state.response = response;
+  return response;
+}
+async function handlePagesWithErrorFallback(state) {
+  if (!state.routeData) {
+    return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
+  }
+  const ctx = state.getAPIContext();
+  if (state.manifest.checkOrigin && isForbiddenCrossOriginRequest(ctx.request, ctx.url, ctx.isPrerendered)) {
+    return createCrossOriginForbiddenResponse(ctx.request);
+  }
+  try {
+    return await handlePages(state, ctx);
+  } catch (err) {
+    state.logger.error(null, err.stack || err.message || String(err));
+    return renderErrorFromState(state, state.request, {
+      ...state.renderOptions,
+      status: 500,
+      error: err,
+      pathname: state.pathname
+    });
+  }
 }
 export {
-  PagesHandler
+  handlePages,
+  handlePagesWithErrorFallback
 };

package/dist/core/redirects/render.js

@@ -1,4 +1,4 @@
-import { PipelineFeatures } from "../base-pipeline.js";
+import { markFeatureUsed, FetchFeatures } from "../fetch/features.js";
 import { getRouteGenerator } from "../routing/generator.js";
 function isExternalURL(url) {
   return url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//");
@@ -34,18 +34,13 @@ function resolveRedirectTarget(params, redirect, redirectRoute, trailingSlash) {
   return redirect.destination;
 }
 async function renderRedirect(state) {
-  state.pipeline.usedFeatures |= PipelineFeatures.redirects;
+  markFeatureUsed(state.manifest, FetchFeatures.redirects);
   const routeData = state.routeData;
   const { redirect, redirectRoute } = routeData;
   const status = computeRedirectStatus(state.request.method, redirect, redirectRoute);
   const headers = {
     location: encodeURI(
-      resolveRedirectTarget(
-        state.params,
-        redirect,
-        redirectRoute,
-        state.pipeline.manifest.trailingSlash
-      )
+      resolveRedirectTarget(state.params, redirect, redirectRoute, state.manifest.trailingSlash)
     )
   };
   if (redirect && redirectIsExternal(redirect)) {

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

@@ -1,4 +1,3 @@
-export { Pipeline } from '../base-pipeline.js';
 export { getParams, getProps } from './params-and-props.js';
 export { loadRenderer } from './renderer.js';
 export { Slots } from './slots.js';

package/dist/core/render/index.js

@@ -1,9 +1,7 @@
-import { Pipeline } from "../base-pipeline.js";
 import { getParams, getProps } from "./params-and-props.js";
 import { loadRenderer } from "./renderer.js";
 import { Slots } from "./slots.js";
 export {
-  Pipeline,
   Slots,
   getParams,
   getProps,

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

@@ -1,7 +1,7 @@
 import type { ComponentInstance } from '../../types/astro.js';
 import type { GetStaticPathsItem, GetStaticPathsResultKeyed, Params } from '../../types/public/common.js';
 import type { AstroConfig, RuntimeMode } from '../../types/public/config.js';
-import type { RouteData } from '../../types/public/internal.js';
+import type { RouteData, SSRManifest } from '../../types/public/internal.js';
 import type { AstroLogger } from '../logger/core.js';
 interface CallGetStaticPathsOptions {
     mod: ComponentInstance | undefined;
@@ -37,5 +37,10 @@ export declare class RouteCache {
     get(route: RouteData): RouteCacheEntry | undefined;
     key(route: RouteData): string;
 }
+/**
+ * The `RouteCache` for a manifest. Cleared via
+ * `getRouteCache(manifest).clearAll()` on dev `astro:content-changed`.
+ */
+export declare function getRouteCache(manifest: SSRManifest): RouteCache;
 export declare function findPathItemByKey(staticPaths: GetStaticPathsResultKeyed, params: Params, route: RouteData, logger: AstroLogger, trailingSlash: AstroConfig['trailingSlash']): GetStaticPathsItem | undefined;
 export {};

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

@@ -1,3 +1,6 @@
+import { getEnvironment } from "../environment/index.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { createManifestMemo } from "../manifest/memo.js";
 import { stringifyParams } from "../routing/params.js";
 import { validateDynamicRouteModule, validateGetStaticPathsResult } from "../routing/validation.js";
 import { generatePaginateFunction } from "./paginate.js";
@@ -68,6 +71,12 @@ class RouteCache {
     return `${route.route}_${route.component}`;
   }
 }
+const routeCaches = createManifestMemo(
+  (manifest) => new RouteCache(getLogger(manifest), getEnvironment(manifest).runtimeMode)
+);
+function getRouteCache(manifest) {
+  return routeCaches.get(manifest);
+}
 function findPathItemByKey(staticPaths, params, route, logger, trailingSlash) {
   const paramsKey = stringifyParams(params, route, trailingSlash);
   const matchedStaticPath = staticPaths.keyed.get(paramsKey);
@@ -79,5 +88,6 @@ function findPathItemByKey(staticPaths, params, route, logger, trailingSlash) {
 export {
   RouteCache,
   callGetStaticPaths,
-  findPathItemByKey
+  findPathItemByKey,
+  getRouteCache
 };