astro 6.2.1 → 6.3.0

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

@@ -1,6 +1,7 @@
 import type { RouteData } from '../../../types/public/index.js';
+import type { ErrorHandler } from '../../errors/handler.js';
 import type { AstroLogger } from '../../logger/core.js';
-import { BaseApp, type DevMatch, type LogRequestPayload, type RenderErrorOptions } from '../base.js';
+import { BaseApp, type DevMatch, type LogRequestPayload } from '../base.js';
 import type { SSRManifest } from '../types.js';
 import { NonRunnablePipeline } from './pipeline.js';
 import type { RoutesList } from '../../../types/astro.js';
@@ -20,6 +21,6 @@ export declare class DevApp extends BaseApp<NonRunnablePipeline> {
     updateRoutes(newRoutesList: RoutesList): void;
     match(request: Request): RouteData | undefined;
     devMatch(pathname: string): Promise<DevMatch | undefined>;
-    renderError(request: Request, { skipMiddleware, error, status, response: _response, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
+    protected createErrorHandler(): ErrorHandler;
     logRequest({ pathname, method, statusCode, isRewrite, reqTime }: LogRequestPayload): void;
 }

package/dist/core/app/dev/app.js

@@ -1,10 +1,6 @@
-import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "../../errors/errors-data.js";
-import { isAstroError } from "../../errors/index.js";
-import {
-  BaseApp
-} from "../base.js";
+import { DevErrorHandler } from "../../errors/dev-handler.js";
+import { BaseApp } from "../base.js";
 import { NonRunnablePipeline } from "./pipeline.js";
-import { getCustom404Route, getCustom500Route } from "../../routing/helpers.js";
 import { ensure404Route } from "../../routing/astro-designed-error-pages.js";
 import { matchRoute } from "../../routing/dev.js";
 import { req } from "../../messages/runtime.js";
@@ -53,60 +49,8 @@ class DevApp extends BaseApp {
       resolvedPathname: matchedRoute.resolvedPathname
     };
   }
-  async renderError(request, {
-    skipMiddleware = false,
-    error,
-    status,
-    response: _response,
-    ...resolvedRenderOptions
-  }) {
-    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
-      throw error;
-    }
-    const renderRoute = async (routeData) => {
-      try {
-        const preloadedComponent = await this.pipeline.getComponentByRoute(routeData);
-        const renderContext = await this.createRenderContext({
-          locals: resolvedRenderOptions.locals,
-          pipeline: this.pipeline,
-          pathname: this.getPathnameFromRequest(request),
-          skipMiddleware,
-          request,
-          routeData,
-          clientAddress: resolvedRenderOptions.clientAddress,
-          status,
-          shouldInjectCspMetaTags: false
-        });
-        renderContext.props.error = error;
-        const response = await renderContext.render(preloadedComponent);
-        if (error) {
-          this.logger.error("router", error.stack || error.message);
-        }
-        return response;
-      } catch (_err) {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status: 500,
-            skipMiddleware: true,
-            error: _err
-          });
-        }
-        throw _err;
-      }
-    };
-    if (status === 404) {
-      const custom404 = getCustom404Route(this.manifestData);
-      if (custom404) {
-        return renderRoute(custom404);
-      }
-    }
-    const custom500 = getCustom500Route(this.manifestData);
-    if (!custom500) {
-      throw error;
-    } else {
-      return renderRoute(custom500);
-    }
+  createErrorHandler() {
+    return new DevErrorHandler(this, { shouldInjectCspMetaTags: false });
   }
   logRequest({ pathname, method, statusCode, isRewrite, reqTime }) {
     if (pathname === "/favicon.ico") {

package/dist/core/app/entrypoints/virtual/dev.js

@@ -1,3 +1,4 @@
+import fetchable from "virtual:astro:fetchable";
 import { manifest } from "virtual:astro:manifest";
 import { DevApp } from "../../dev/app.js";
 import { createConsoleLogger } from "../../../logger/impls/console.js";
@@ -5,6 +6,7 @@ let currentDevApp = null;
 const createApp = ({ streaming } = {}) => {
   const logger = createConsoleLogger(manifest.logLevel);
   currentDevApp = new DevApp(manifest, streaming, logger);
+  currentDevApp.setFetchHandler(fetchable);
   if (import.meta.hot) {
     import.meta.hot.on("astro:routes-updated", async () => {
       if (!currentDevApp) return;

package/dist/core/app/entrypoints/virtual/prod.js

@@ -1,7 +1,10 @@
+import fetchable from "virtual:astro:fetchable";
 import { manifest } from "virtual:astro:manifest";
 import { App } from "../../app.js";
 const createApp = ({ streaming } = {}) => {
-  return new App(manifest, streaming);
+  const app = new App(manifest, streaming);
+  app.setFetchHandler(fetchable);
+  return app;
 };
 export {
   createApp

package/dist/core/app/prepare-response.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Strips internal-only headers from the response before sending it to the
+ * user agent, and optionally appends cookies written via `Astro.cookie.set()`
+ * to the `Set-Cookie` header.
+ *
+ * This is a pure function with no dependencies on the app; it is shared by
+ * `AstroHandler` and the various error handlers.
+ */
+export declare function prepareResponse(response: Response, { addCookieHeader }: {
+    addCookieHeader: boolean;
+}): void;

package/dist/core/app/prepare-response.js

@@ -0,0 +1,18 @@
+import { INTERNAL_RESPONSE_HEADERS, responseSentSymbol } from "../constants.js";
+import { getSetCookiesFromResponse } from "../cookies/index.js";
+function prepareResponse(response, { addCookieHeader }) {
+  for (const headerName of INTERNAL_RESPONSE_HEADERS) {
+    if (response.headers.has(headerName)) {
+      response.headers.delete(headerName);
+    }
+  }
+  if (addCookieHeader) {
+    for (const setCookieHeaderValue of getSetCookiesFromResponse(response)) {
+      response.headers.append("set-cookie", setCookieHeaderValue);
+    }
+  }
+  Reflect.set(response, responseSentSymbol, true);
+}
+export {
+  prepareResponse
+};

package/dist/core/app/render-options.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedRenderOptions } from './base.js';
+/**
+ * Reads `ResolvedRenderOptions` that were attached to a request via
+ * `renderOptionsSymbol`. Returns `undefined` if no options are attached.
+ */
+export declare function getRenderOptions(request: Request): ResolvedRenderOptions | undefined;
+/**
+ * Attaches `ResolvedRenderOptions` to a request via `renderOptionsSymbol` so
+ * that downstream handlers can read them.
+ */
+export declare function setRenderOptions(request: Request, options: ResolvedRenderOptions): void;

package/dist/core/app/render-options.js

@@ -0,0 +1,11 @@
+const renderOptionsSymbol = /* @__PURE__ */ Symbol.for("astro.renderOptions");
+function getRenderOptions(request) {
+  return Reflect.get(request, renderOptionsSymbol);
+}
+function setRenderOptions(request, options) {
+  Reflect.set(request, renderOptionsSymbol, options);
+}
+export {
+  getRenderOptions,
+  setRenderOptions
+};

package/dist/core/base-pipeline.d.ts

@@ -14,13 +14,29 @@ import type { CompiledCacheRoute } from './cache/runtime/route-matching.js';
 import type { SessionDriverFactory } from './session/types.js';
 import { NodePool } from '../runtime/server/render/queue/pool.js';
 import { HTMLStringCache } from '../runtime/server/html-string-cache.js';
+/**
+ * Bit flags for pipeline features that handler classes register as
+ * "used" when a custom `src/app.ts` fetch handler is in play. After the
+ * first request (dev) or at runtime (prod SSR), we compare against the
+ * manifest to warn about features the user configured but forgot to
+ * include in their custom pipeline.
+ */
+export declare const PipelineFeatures: {
+    readonly redirects: number;
+    readonly sessions: number;
+    readonly actions: number;
+    readonly middleware: number;
+    readonly i18n: number;
+    readonly cache: number;
+};
 /**
  * The `Pipeline` represents the static parts of rendering that do not change between requests.
  * These are mostly known when the server first starts up and do not change.
  *
- * Thus, a `Pipeline` is created once at process start and then used by every `RenderContext`.
+ * Thus, a `Pipeline` is created once at process start and then used by every `FetchState`.
  */
 export declare abstract class Pipeline {
+    #private;
     readonly internalMiddleware: MiddlewareHandler[];
     resolvedMiddleware: MiddlewareHandler | undefined;
     resolvedLogger: boolean;
@@ -30,6 +46,12 @@ export declare abstract class Pipeline {
     compiledCacheRoutes: CompiledCacheRoute[] | undefined;
     nodePool: NodePool | undefined;
     htmlStringCache: HTMLStringCache | undefined;
+    /**
+     * Bit mask of pipeline features activated by handler classes.
+     * Each handler sets its bit via `|=`. Only meaningful when a
+     * custom `src/app.ts` fetch handler is in use.
+     */
+    usedFeatures: number;
     logger: AstroLogger;
     readonly manifest: SSRManifest;
     /**
@@ -63,6 +85,10 @@ export declare abstract class Pipeline {
     readonly cacheProvider: SSRManifest['cacheProvider'];
     readonly cacheConfig: SSRManifest['cacheConfig'];
     readonly serverIslands: SSRManifest['serverIslandMappings'];
+    /** Route data derived from the manifest, used for route matching. */
+    manifestData: {
+        routes: RouteData[];
+    };
     constructor(logger: AstroLogger, manifest: SSRManifest, 
     /**
      * "development" or "production" only
@@ -85,6 +111,17 @@ export declare abstract class Pipeline {
     }>) | undefined, cacheProvider?: (() => Promise<{
         default: CacheProviderFactory | null;
     }>) | undefined, cacheConfig?: import("./cache/types.js").SSRManifestCache | undefined, serverIslands?: (() => Promise<ServerIslandMappings> | ServerIslandMappings) | undefined);
+    /**
+     * Low-level route matching against the manifest routes. Returns the
+     * matched `RouteData` or `undefined`. Does not filter prerendered
+     * routes or check public assets — use `BaseApp.match()` for that.
+     */
+    matchRoute(pathname: string): RouteData | undefined;
+    /**
+     * Rebuilds the internal router after routes have been added or
+     * removed (e.g. by the dev server on HMR).
+     */
+    rebuildRouter(): void;
     abstract headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
     abstract componentMetadata(routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
     /**

package/dist/core/base-pipeline.js

@@ -1,5 +1,4 @@
 import { NOOP_ACTIONS_MOD } from "../actions/noop-actions.js";
-import { createI18nMiddleware } from "../i18n/middleware.js";
 import { createOriginCheckMiddleware } from "./app/middlewares.js";
 import { ActionNotFoundError } from "./errors/errors-data.js";
 import { AstroError } from "./errors/index.js";
@@ -8,10 +7,20 @@ import { sequence } from "./middleware/sequence.js";
 import { RedirectSinglePageBuiltModule } from "./redirects/index.js";
 import { RouteCache } from "./render/route-cache.js";
 import { createDefaultRoutes } from "./routing/default.js";
+import { ensure404Route } from "./routing/astro-designed-error-pages.js";
+import { Router } from "./routing/router.js";
 import { NodePool } from "../runtime/server/render/queue/pool.js";
 import { HTMLStringCache } from "../runtime/server/html-string-cache.js";
 import { FORBIDDEN_PATH_KEYS } from "@astrojs/internal-helpers/object";
 import { loadLogger } from "./logger/load.js";
+const PipelineFeatures = {
+  redirects: 1 << 0,
+  sessions: 1 << 1,
+  actions: 1 << 2,
+  middleware: 1 << 3,
+  i18n: 1 << 4,
+  cache: 1 << 5
+};
 class Pipeline {
   internalMiddleware;
   resolvedMiddleware = void 0;
@@ -22,6 +31,12 @@ class Pipeline {
   compiledCacheRoutes = void 0;
   nodePool;
   htmlStringCache;
+  /**
+   * Bit mask of pipeline features activated by handler classes.
+   * Each handler sets its bit via `|=`. Only meaningful when a
+   * custom `src/app.ts` fetch handler is in use.
+   */
+  usedFeatures = 0;
   logger;
   manifest;
   /**
@@ -55,6 +70,10 @@ class Pipeline {
   cacheProvider;
   cacheConfig;
   serverIslands;
+  /** Route data derived from the manifest, used for route matching. */
+  manifestData;
+  /** Pattern-matching router built from manifestData. */
+  #router;
   constructor(logger, manifest, runtimeMode, renderers, resolve, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : void 0, defaultRoutes = createDefaultRoutes(manifest), actions = manifest.actions, sessionDriver = manifest.sessionDriver, cacheProvider = manifest.cacheProvider, cacheConfig = manifest.cacheConfig, serverIslands = manifest.serverIslandMappings) {
     this.logger = logger;
     this.manifest = manifest;
@@ -76,12 +95,14 @@ class Pipeline {
     this.cacheProvider = cacheProvider;
     this.cacheConfig = cacheConfig;
     this.serverIslands = serverIslands;
+    this.manifestData = { routes: (manifest.routes ?? []).map((route) => route.routeData) };
+    ensure404Route(this.manifestData);
+    this.#router = new Router(this.manifestData.routes, {
+      base: manifest.base,
+      trailingSlash: manifest.trailingSlash,
+      buildFormat: manifest.buildFormat
+    });
     this.internalMiddleware = [];
-    if (i18n?.strategy !== "manual") {
-      this.internalMiddleware.push(
-        createI18nMiddleware(i18n, manifest.base, manifest.trailingSlash, manifest.buildFormat)
-      );
-    }
     if (manifest.experimentalQueuedRendering.enabled) {
       this.nodePool = this.createNodePool(
         manifest.experimentalQueuedRendering.poolSize ?? 1e3,
@@ -92,6 +113,27 @@ class Pipeline {
       }
     }
   }
+  /**
+   * Low-level route matching against the manifest routes. Returns the
+   * matched `RouteData` or `undefined`. Does not filter prerendered
+   * routes or check public assets — use `BaseApp.match()` for that.
+   */
+  matchRoute(pathname) {
+    const match = this.#router.match(pathname, { allowWithoutBase: true });
+    if (match.type !== "match") return void 0;
+    return match.route;
+  }
+  /**
+   * Rebuilds the internal router after routes have been added or
+   * removed (e.g. by the dev server on HMR).
+   */
+  rebuildRouter() {
+    this.#router = new Router(this.manifestData.routes, {
+      base: this.manifest.base,
+      trailingSlash: this.manifest.trailingSlash,
+      buildFormat: this.manifest.buildFormat
+    });
+  }
   /**
    * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
    * it returns a no-op function
@@ -243,5 +285,6 @@ class Pipeline {
   }
 }
 export {
-  Pipeline
+  Pipeline,
+  PipelineFeatures
 };

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

@@ -1,20 +1,19 @@
-import { BaseApp, type RenderErrorOptions } from '../app/entrypoints/index.js';
+import { BaseApp } from '../app/entrypoints/index.js';
 import type { SSRManifest } from '../app/types.js';
 import type { BuildInternals } from './internal.js';
 import { BuildPipeline } from './pipeline.js';
 import type { StaticBuildOptions } from './types.js';
-import type { CreateRenderContext, RenderContext } from '../render-context.js';
 import type { LogRequestPayload } from '../app/base.js';
+import type { ErrorHandler } from '../errors/handler.js';
 import type { PoolStatsReport } from '../../runtime/server/render/queue/pool.js';
 export declare class BuildApp extends BaseApp<BuildPipeline> {
     createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
-    createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
     isDev(): boolean;
     setInternals(internals: BuildInternals): void;
     setOptions(options: StaticBuildOptions): void;
     getOptions(): StaticBuildOptions;
     getSettings(): import("../../types/astro.js").AstroSettings;
-    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+    protected createErrorHandler(): ErrorHandler;
     getQueueStats(): PoolStatsReport | undefined;
     logRequest(_options: LogRequestPayload): void;
 }

package/dist/core/build/app.js

@@ -1,16 +1,12 @@
 import { BaseApp } from "../app/entrypoints/index.js";
 import { BuildPipeline } from "./pipeline.js";
+import { BuildErrorHandler } from "../errors/build-handler.js";
 class BuildApp extends BaseApp {
   createPipeline(_streaming, manifest, ..._args) {
     return BuildPipeline.create({
       manifest
     });
   }
-  async createRenderContext(payload) {
-    return await super.createRenderContext({
-      ...payload
-    });
-  }
   isDev() {
     return true;
   }
@@ -28,18 +24,8 @@ class BuildApp extends BaseApp {
   getSettings() {
     return this.pipeline.getSettings();
   }
-  async renderError(request, options) {
-    if (options.status === 500) {
-      if (options.response) {
-        return options.response;
-      }
-      throw options.error;
-    } else {
-      return super.renderError(request, {
-        ...options,
-        prerenderedErrorPageFetch: void 0
-      });
-    }
+  createErrorHandler() {
+    return new BuildErrorHandler(this);
   }
   getQueueStats() {
     if (this.pipeline.nodePool) {

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

@@ -1,6 +1,7 @@
 import { isCSSRequest } from "vite";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
 import { isPropagatedAssetBoundary } from "../../head-propagation/boundary.js";
+import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../../vite-plugin-pages/const.js";
 import {
   getParentExtendedModuleInfos,
   getParentModuleInfos,
@@ -18,7 +19,12 @@ function pluginCSS(options, internals) {
 function isBuildCssBoundary(id, ctx) {
   if (isPropagatedAssetBoundary(id)) return true;
   const info = ctx.getModuleInfo(id);
-  return info ? moduleIsTopLevelPage(info) : false;
+  if (!info || !moduleIsTopLevelPage(info)) return false;
+  const allImporters = info.importers.concat(info.dynamicImporters);
+  const hasNonVirtualPageImporter = allImporters.some(
+    (importer) => !importer.includes(VIRTUAL_PAGE_RESOLVED_MODULE_ID)
+  );
+  return !hasNonVirtualPageImporter;
 }
 function rollupPluginAstroBuildCSS(options) {
   const { internals, buildOptions } = options;

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

@@ -47,7 +47,8 @@ async function manifestBuildPostHook(options, internals, {
       logger: options.logger,
       middlewareEntryPoint: shouldPassMiddlewareEntryPoint ? internals.middlewareEntryPoint : void 0
     });
-    const code = injectManifest(manifest, ssrManifestChunk.code);
+    const ssrManifest = stripPrerenderedRouteStyles(manifest);
+    const code = injectManifest(ssrManifest, ssrManifestChunk.code);
     mutate(ssrManifestChunk.fileName, code, false);
   }
   const prerenderManifestChunk = chunks.find(
@@ -82,6 +83,15 @@ function injectManifest(manifest, code) {
     return JSON.stringify(manifest);
   });
 }
+function stripPrerenderedRouteStyles(manifest) {
+  let stripped = false;
+  const routes = manifest.routes.map((route) => {
+    if (!route.routeData.prerender || route.styles.length === 0) return route;
+    stripped = true;
+    return { ...route, styles: [] };
+  });
+  return stripped ? { ...manifest, routes } : manifest;
+}
 async function buildManifest(opts, internals, staticFiles, encodedKey) {
   const { settings } = opts;
   const routes = [];

package/dist/core/build/static-build.js

@@ -186,7 +186,14 @@ async function buildEnvironments(opts, internals) {
             }
             return [prefix, cleanChunkName(name), suffix].join("");
           },
-          assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
+          assetFileNames(assetInfo) {
+            const name = assetInfo.names?.[0] ?? "";
+            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
+              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
+              return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
+            }
+            return `${settings.config.build.assets}/[name].[hash][extname]`;
+          },
           ...viteConfig.build?.rollupOptions?.output,
           entryFileNames(chunkInfo) {
             if (chunkInfo.facadeModuleId?.startsWith(VIRTUAL_PAGE_RESOLVED_MODULE_ID)) {
@@ -289,7 +296,14 @@ async function buildEnvironments(opts, internals) {
               chunkFileNames(chunkInfo) {
                 return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
               },
-              assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
+              assetFileNames(assetInfo) {
+                const name = assetInfo.names?.[0] ?? "";
+                if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
+                  const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
+                  return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
+                }
+                return `${settings.config.build.assets}/[name].[hash][extname]`;
+              },
               ...viteConfig.environments?.client?.build?.rollupOptions?.output
             }
           }

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

@@ -0,0 +1,29 @@
+import type { BaseApp } from '../app/base.js';
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { Pipeline } from '../base-pipeline.js';
+/**
+ * Registers a cache provider on the given `FetchState`. When
+ * `state.resolve('cache')` is first called, the appropriate cache
+ * implementation is created (disabled, noop for dev, or real).
+ *
+ * Returns synchronously when cache is not configured or in dev mode.
+ */
+export declare function provideCache(state: FetchState): Promise<void> | void;
+/**
+ * Wraps a render callback with cache provider logic. Handles both
+ * runtime caching (onRequest) and CDN-based providers (headers only).
+ *
+ * - When a cache provider with `onRequest` is configured, the callback
+ *   is wrapped so the provider can serve from cache or fall through.
+ * - When only CDN headers are needed, the callback runs directly and
+ *   cache headers are applied to the response.
+ * - When no cache provider is configured, the callback runs as-is.
+ *
+ * Cache headers (`CDN-Cache-Control`, `Cache-Tag`) are stripped from
+ * the final response after the runtime provider has read them.
+ */
+export declare class CacheHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    handle(state: FetchState, next: () => Promise<Response>): Promise<Response>;
+}

package/dist/core/cache/handler.js

@@ -0,0 +1,81 @@
+import { PipelineFeatures } from "../base-pipeline.js";
+import { AstroCache, applyCacheHeaders } from "./runtime/cache.js";
+import { NoopAstroCache, DisabledAstroCache } from "./runtime/noop.js";
+import { compileCacheRoutes, matchCacheRoute } from "./runtime/route-matching.js";
+const CACHE_KEY = "cache";
+function provideCache(state) {
+  const pipeline = state.pipeline;
+  if (!pipeline.cacheConfig) {
+    state.provide(CACHE_KEY, {
+      create: () => new DisabledAstroCache(pipeline.logger)
+    });
+    return;
+  }
+  if (pipeline.runtimeMode === "development") {
+    state.provide(CACHE_KEY, {
+      create: () => new NoopAstroCache()
+    });
+    return;
+  }
+  return provideCacheAsync(state, pipeline);
+}
+async function provideCacheAsync(state, pipeline) {
+  const cacheProvider = await pipeline.getCacheProvider();
+  state.provide(CACHE_KEY, {
+    create() {
+      const cache = new AstroCache(cacheProvider);
+      if (pipeline.cacheConfig?.routes) {
+        if (!pipeline.compiledCacheRoutes) {
+          pipeline.compiledCacheRoutes = compileCacheRoutes(
+            pipeline.cacheConfig.routes,
+            pipeline.manifest.base,
+            pipeline.manifest.trailingSlash
+          );
+        }
+        const matched = matchCacheRoute(state.pathname, pipeline.compiledCacheRoutes);
+        if (matched) {
+          cache.set(matched);
+        }
+      }
+      return cache;
+    }
+  });
+}
+class CacheHandler {
+  #app;
+  constructor(app) {
+    this.#app = app;
+  }
+  async handle(state, next) {
+    this.#app.pipeline.usedFeatures |= PipelineFeatures.cache;
+    if (!this.#app.pipeline.cacheProvider) {
+      return next();
+    }
+    const cache = state.resolve(CACHE_KEY);
+    const cacheProvider = await this.#app.pipeline.getCacheProvider();
+    if (cacheProvider?.onRequest) {
+      const response2 = await cacheProvider.onRequest(
+        {
+          request: state.request,
+          url: new URL(state.request.url),
+          waitUntil: state.renderOptions.waitUntil
+        },
+        async () => {
+          const res = await next();
+          applyCacheHeaders(cache, res);
+          return res;
+        }
+      );
+      response2.headers.delete("CDN-Cache-Control");
+      response2.headers.delete("Cache-Tag");
+      return response2;
+    }
+    const response = await next();
+    applyCacheHeaders(cache, response);
+    return response;
+  }
+}
+export {
+  CacheHandler,
+  provideCache
+};

package/dist/core/compile/style.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import { preprocessCSS } from "vite";
 import { AstroErrorData, CSSError, positionAt } from "../errors/index.js";
 import { normalizePath } from "../viteUtils.js";
@@ -31,6 +32,21 @@ function rewriteCssUrls(css, base) {
     return match;
   });
 }
+function withNestingExcluded(viteConfig) {
+  let Features;
+  try {
+    const requireFromRoot = createRequire(viteConfig.root + "/");
+    Features = requireFromRoot("lightningcss").Features;
+  } catch {
+    return void 0;
+  }
+  const lcss = viteConfig.css?.lightningcss ?? {};
+  const prevExclude = lcss.exclude ?? 0;
+  return {
+    ...viteConfig,
+    css: { ...viteConfig.css, lightningcss: { ...lcss, exclude: prevExclude | Features.Nesting } }
+  };
+}
 function createStylePreprocessor({
   filename,
   viteConfig,
@@ -44,7 +60,8 @@ function createStylePreprocessor({
     const lang = `.${attrs?.lang || "css"}`.toLowerCase();
     const id = `${filename}?astro&type=style&index=${index}&lang${lang}`;
     try {
-      const result = await preprocessCSS(content, id, viteConfig);
+      const effectiveViteConfig = viteConfig.css?.transformer === "lightningcss" ? withNestingExcluded(viteConfig) ?? viteConfig : viteConfig;
+      const result = await preprocessCSS(content, id, effectiveViteConfig);
       const rewrittenCode = rewriteCssUrls(result.code, astroConfig.base);
       cssPartialCompileResults[index] = {
         // Use `in` operator to handle both Go compiler (boolean `true`) and

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

@@ -1,4 +1,4 @@
 export { resolveConfig, resolveConfigPath, resolveRoot, } from './config.js';
 export { mergeConfig } from './merge.js';
 export { createSettings } from './settings.js';
-export { loadTSConfig, updateTSConfigForFramework } from './tsconfig.js';
+export { loadTSConfig, updateTSConfigForFramework, type TSConfigLoadedResult, type TSConfigResult, } from './tsconfig.js';

package/dist/core/config/index.js

@@ -5,7 +5,10 @@ import {
 } from "./config.js";
 import { mergeConfig } from "./merge.js";
 import { createSettings } from "./settings.js";
-import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
+import {
+  loadTSConfig,
+  updateTSConfigForFramework
+} from "./tsconfig.js";
 export {
   createSettings,
   loadTSConfig,