astro 7.0.0-alpha.1 → 7.0.0-alpha.2

package/dist/core/app/base.js

@@ -1,12 +1,10 @@
 import {
-  appendForwardSlash,
   collapseDuplicateLeadingSlashes,
-  joinPaths,
   prependForwardSlash,
   removeTrailingForwardSlash
 } from "@astrojs/internal-helpers/path";
 import { matchPattern } from "@astrojs/internal-helpers/remote";
-import { normalizeTheLocale } from "../../i18n/index.js";
+import { computePathnameFromDomain } from "../i18n/domain.js";
 import { PipelineFeatures } from "../base-pipeline.js";
 import { ASTRO_ERROR_HEADER, clientAddressSymbol } from "../constants.js";
 import { getSetCookiesFromResponse } from "../cookies/index.js";
@@ -16,6 +14,7 @@ import { DefaultFetchHandler } from "../fetch/default-handler.js";
 import { appSymbol } from "../constants.js";
 import { DefaultErrorHandler } from "../errors/default-handler.js";
 import { setRenderOptions } from "./render-options.js";
+import { MultiLevelEncodingError } from "../util/pathname.js";
 class BaseApp {
   manifest;
   manifestData;
@@ -116,19 +115,30 @@ class BaseApp {
     return pathname;
   }
   /**
-   * Extracts the base-stripped, decoded pathname from a request.
-   * Used by adapters to compute the pathname for dev-mode route matching.
+   * Decodes a pathname with `decodeURI`, falling back to the raw pathname when it
+   * contains an invalid percent-sequence (e.g. `%C0%AF`, an overlong-UTF-8 encoding of
+   * `/` commonly sent by path-traversal scanners). A raw `decodeURI()` would throw
+   * `URIError: URI malformed`, and because `match()` runs before `render()` that error
+   * escapes the adapter's request handler as an uncaught exception (HTTP 500) that user
+   * middleware can't catch.
    */
-  getPathnameFromRequest(request) {
-    const url = new URL(request.url);
-    const pathname = prependForwardSlash(this.removeBase(url.pathname));
+  safeDecodeURI(pathname) {
     try {
       return decodeURI(pathname);
     } catch (e) {
-      this.adapterLogger.error(e.toString());
+      this.adapterLogger.debug(e.toString());
       return pathname;
     }
   }
+  /**
+   * Extracts the base-stripped, decoded pathname from a request.
+   * Used by adapters to compute the pathname for dev-mode route matching.
+   */
+  getPathnameFromRequest(request) {
+    const url = new URL(request.url);
+    const pathname = prependForwardSlash(this.removeBase(url.pathname));
+    return this.safeDecodeURI(pathname);
+  }
   /**
    * Given a `Request`, it returns the `RouteData` that matches its `pathname`. By default, prerendered
    * routes aren't returned, even if they are matched.
@@ -144,12 +154,16 @@ class BaseApp {
     if (!pathname) {
       pathname = prependForwardSlash(this.removeBase(url.pathname));
     }
-    const routeData = this.pipeline.matchRoute(decodeURI(pathname));
+    const routeData = this.pipeline.matchRoute(this.safeDecodeURI(pathname));
     if (!routeData) return void 0;
     if (allowPrerenderedRoutes) {
       return routeData;
     }
     if (routeData.prerender) {
+      if (routeData.params.length > 0) {
+        const allMatches = this.pipeline.matchAllRoutes(this.safeDecodeURI(pathname));
+        return allMatches.find((r) => !r.prerender);
+      }
       return void 0;
     }
     return routeData;
@@ -165,55 +179,14 @@ class BaseApp {
     return void 0;
   }
   computePathnameFromDomain(request) {
-    let pathname = void 0;
-    const url = new URL(request.url);
-    if (this.manifest.i18n && (this.manifest.i18n.strategy === "domains-prefix-always" || this.manifest.i18n.strategy === "domains-prefix-other-locales" || this.manifest.i18n.strategy === "domains-prefix-always-no-redirect")) {
-      let host = request.headers.get("X-Forwarded-Host");
-      let protocol = request.headers.get("X-Forwarded-Proto");
-      if (protocol) {
-        protocol = protocol + ":";
-      } else {
-        protocol = url.protocol;
-      }
-      if (!host) {
-        host = request.headers.get("Host");
-      }
-      if (host && protocol) {
-        host = host.split(":")[0];
-        try {
-          let locale;
-          const hostAsUrl = new URL(`${protocol}//${host}`);
-          for (const [domainKey, localeValue] of Object.entries(
-            this.manifest.i18n.domainLookupTable
-          )) {
-            const domainKeyAsUrl = new URL(domainKey);
-            if (hostAsUrl.host === domainKeyAsUrl.host && hostAsUrl.protocol === domainKeyAsUrl.protocol) {
-              locale = localeValue;
-              break;
-            }
-          }
-          if (locale) {
-            pathname = prependForwardSlash(
-              joinPaths(normalizeTheLocale(locale), this.removeBase(url.pathname))
-            );
-            if (this.manifest.trailingSlash === "always") {
-              pathname = appendForwardSlash(pathname);
-            } else if (this.manifest.trailingSlash === "never") {
-              pathname = removeTrailingForwardSlash(pathname);
-            } else if (url.pathname.endsWith("/")) {
-              pathname = appendForwardSlash(pathname);
-            }
-          }
-        } catch (e) {
-          this.logger.error(
-            "router",
-            `Astro tried to parse ${protocol}//${host} as an URL, but it threw a parsing error. Check the X-Forwarded-Host and X-Forwarded-Proto headers.`
-          );
-          this.logger.error("router", `Error: ${e}`);
-        }
-      }
-    }
-    return pathname;
+    return computePathnameFromDomain(
+      request,
+      new URL(request.url),
+      this.manifest.i18n,
+      this.manifest.base,
+      this.manifest.trailingSlash,
+      this.logger
+    );
   }
   async render(request, {
     addCookieHeader = false,
@@ -254,7 +227,7 @@ class BaseApp {
     if (!routeData) {
       const domainPathname = this.computePathnameFromDomain(request);
       if (domainPathname) {
-        routeData = this.pipeline.matchRoute(decodeURI(domainPathname));
+        routeData = this.pipeline.matchRoute(this.safeDecodeURI(domainPathname));
       }
     }
     const resolvedOptions = {
@@ -266,13 +239,20 @@ class BaseApp {
       waitUntil
     };
     let response;
-    if (this.#fetchHandler instanceof DefaultFetchHandler) {
-      Reflect.set(request, appSymbol, this);
-      response = await this.#fetchHandler.renderWithOptions(request, resolvedOptions);
-    } else {
-      setRenderOptions(request, resolvedOptions);
-      Reflect.set(request, appSymbol, this);
-      response = await this.#fetchHandler.fetch(request);
+    try {
+      if (this.#fetchHandler instanceof DefaultFetchHandler) {
+        Reflect.set(request, appSymbol, this);
+        response = await this.#fetchHandler.renderWithOptions(request, resolvedOptions);
+      } else {
+        setRenderOptions(request, resolvedOptions);
+        Reflect.set(request, appSymbol, this);
+        response = await this.#fetchHandler.fetch(request);
+      }
+    } catch (err) {
+      if (err instanceof MultiLevelEncodingError) {
+        return new Response("Bad Request", { status: 400 });
+      }
+      throw err;
     }
     this.#warnMissingFeatures();
     if (response.headers.get(ASTRO_ERROR_HEADER)) {

package/dist/core/app/entrypoints/node.d.ts

@@ -1 +1 @@
-export { NodeApp, loadApp, loadManifest, createRequest, writeResponse, getAbortControllerCleanup, } from '../node.js';
+export { NodeApp, loadApp, loadManifest, createRequest, createRequestFromNodeRequest, writeResponse, getAbortControllerCleanup, } from '../node.js';

package/dist/core/app/entrypoints/node.js

@@ -3,12 +3,14 @@ import {
   loadApp,
   loadManifest,
   createRequest,
+  createRequestFromNodeRequest,
   writeResponse,
   getAbortControllerCleanup
 } from "../node.js";
 export {
   NodeApp,
   createRequest,
+  createRequestFromNodeRequest,
   getAbortControllerCleanup,
   loadApp,
   loadManifest,

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

@@ -25,6 +25,22 @@ interface NodeRequest extends IncomingMessage {
  * })
  * ```
  */
+/**
+ * Internal version of `createRequest` that skips X-Forwarded-* header
+ * validation. Forwarded headers are resolved later inside `FetchState`,
+ * so doing it here too would duplicate work on every request.
+ *
+ * Use this for all internal call sites that go through `app.render()`
+ * (which creates a `FetchState`). The public `createRequest` keeps the
+ * forwarded header logic for external adapters that may not use
+ * `FetchState`.
+ */
+export declare function createRequestFromNodeRequest(req: NodeRequest, { skipBody, allowedDomains, bodySizeLimit, port: serverPort, }?: {
+    skipBody?: boolean;
+    allowedDomains?: Partial<RemotePattern>[];
+    bodySizeLimit?: number;
+    port?: number;
+}): Request;
 export declare function createRequest(req: NodeRequest, { skipBody, allowedDomains, bodySizeLimit, port: serverPort, }?: {
     skipBody?: boolean;
     allowedDomains?: Partial<RemotePattern>[];

package/dist/core/app/node.js

@@ -9,6 +9,48 @@ import {
   validateForwardedHeaders,
   validateHost
 } from "./validate-headers.js";
+function createRequestFromNodeRequest(req, {
+  skipBody = false,
+  allowedDomains = [],
+  bodySizeLimit,
+  port: serverPort
+} = {}) {
+  const controller = new AbortController();
+  const isEncrypted = "encrypted" in req.socket && req.socket.encrypted;
+  const protocol = isEncrypted ? "https" : "http";
+  const hostname = typeof req.headers.host === "string" ? req.headers.host : typeof req.headers[":authority"] === "string" ? req.headers[":authority"] : serverPort ? `localhost:${serverPort}` : "localhost";
+  let url;
+  try {
+    url = new URL(`${protocol}://${hostname}${req.url}`);
+  } catch {
+    url = new URL(`${protocol}://${hostname}`);
+  }
+  const options = {
+    method: req.method || "GET",
+    headers: makeRequestHeaders(req),
+    signal: controller.signal
+  };
+  const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
+  if (bodyAllowed) {
+    Object.assign(options, makeRequestBody(req, bodySizeLimit));
+  }
+  const request = new Request(url, options);
+  wireAbortController(req, controller);
+  const untrustedHostname = req.headers.host ?? req.headers[":authority"];
+  const validatedHostname = validateHost(
+    typeof untrustedHostname === "string" ? untrustedHostname : void 0,
+    protocol,
+    allowedDomains
+  );
+  const forwardedHost = getFirstForwardedValue(req.headers["x-forwarded-host"]);
+  const hostValidated = validatedHostname !== void 0 || forwardedHost !== void 0 && allowedDomains.length > 0;
+  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
+  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
+  if (clientIp) {
+    Reflect.set(request, clientAddressSymbol, clientIp);
+  }
+  return request;
+}
 function createRequest(req, {
   skipBody = false,
   allowedDomains = [],
@@ -51,6 +93,16 @@ function createRequest(req, {
     Object.assign(options, makeRequestBody(req, bodySizeLimit));
   }
   const request = new Request(url, options);
+  wireAbortController(req, controller);
+  const hostValidated = validated.host !== void 0 || validatedHostname !== void 0;
+  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
+  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
+  if (clientIp) {
+    Reflect.set(request, clientAddressSymbol, clientIp);
+  }
+  return request;
+}
+function wireAbortController(req, controller) {
   const socket = getRequestSocket(req);
   if (socket && typeof socket.on === "function") {
     const existingCleanup = getAbortControllerCleanup(req);
@@ -85,13 +137,6 @@ function createRequest(req, {
       onSocketClose();
     }
   }
-  const hostValidated = validated.host !== void 0 || validatedHostname !== void 0;
-  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
-  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
-  if (clientIp) {
-    Reflect.set(request, clientAddressSymbol, clientIp);
-  }
-  return request;
 }
 async function writeResponse(source, destination) {
   const { status, headers, body, statusText } = source;
@@ -147,18 +192,15 @@ class NodeApp extends App {
   }
   match(req, allowPrerenderedRoutes = false) {
     if (!(req instanceof Request)) {
-      req = createRequest(req, {
-        skipBody: true,
-        allowedDomains: this.manifest.allowedDomains
+      req = createRequestFromNodeRequest(req, {
+        skipBody: true
       });
     }
     return super.match(req, allowPrerenderedRoutes);
   }
   render(request, options) {
     if (!(request instanceof Request)) {
-      request = createRequest(request, {
-        allowedDomains: this.manifest.allowedDomains
-      });
+      request = createRequestFromNodeRequest(request);
     }
     return super.render(request, options);
   }
@@ -219,6 +261,9 @@ function makeRequestBody(req, bodySizeLimit) {
     if (typeof req.body === "string" && req.body.length > 0) {
       return { body: Buffer.from(req.body) };
     }
+    if (req.body instanceof ArrayBuffer || ArrayBuffer.isView(req.body)) {
+      return { body: req.body };
+    }
     if (typeof req.body === "object" && req.body !== null && Object.keys(req.body).length > 0) {
       return { body: Buffer.from(JSON.stringify(req.body)) };
     }
@@ -280,6 +325,7 @@ async function loadApp(rootFolder) {
 export {
   NodeApp,
   createRequest,
+  createRequestFromNodeRequest,
   getAbortControllerCleanup,
   loadApp,
   loadManifest,

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

@@ -29,6 +29,9 @@ export declare const PipelineFeatures: {
     readonly i18n: number;
     readonly cache: number;
 };
+/** All feature bits ORed together. Keep next to `PipelineFeatures` so
+ *  new flags are hard to forget. */
+export declare const ALL_PIPELINE_FEATURES: 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.
@@ -117,6 +120,13 @@ export declare abstract class Pipeline {
      * routes or check public assets — use `BaseApp.match()` for that.
      */
     matchRoute(pathname: string): RouteData | undefined;
+    /**
+     * Returns all routes matching the given pathname, in priority order.
+     * Used when the first match cannot serve the request (e.g. a
+     * prerendered dynamic route that doesn't cover this specific path)
+     * and the caller needs to try subsequent matches.
+     */
+    matchAllRoutes(pathname: string): RouteData[];
     /**
      * Rebuilds the internal router after routes have been added or
      * removed (e.g. by the dev server on HMR).

package/dist/core/base-pipeline.js

@@ -21,6 +21,7 @@ const PipelineFeatures = {
   i18n: 1 << 4,
   cache: 1 << 5
 };
+const ALL_PIPELINE_FEATURES = PipelineFeatures.redirects | PipelineFeatures.sessions | PipelineFeatures.actions | PipelineFeatures.middleware | PipelineFeatures.i18n | PipelineFeatures.cache;
 class Pipeline {
   internalMiddleware;
   resolvedMiddleware = void 0;
@@ -123,6 +124,15 @@ class Pipeline {
     if (match.type !== "match") return void 0;
     return match.route;
   }
+  /**
+   * Returns all routes matching the given pathname, in priority order.
+   * Used when the first match cannot serve the request (e.g. a
+   * prerendered dynamic route that doesn't cover this specific path)
+   * and the caller needs to try subsequent matches.
+   */
+  matchAllRoutes(pathname) {
+    return this.#router.matchAll(pathname, { allowWithoutBase: true });
+  }
   /**
    * Rebuilds the internal router after routes have been added or
    * removed (e.g. by the dev server on HMR).
@@ -182,7 +192,8 @@ class Pipeline {
     if (this.resolvedActions) {
       return this.resolvedActions;
     } else if (this.actions) {
-      return this.actions();
+      this.resolvedActions = await this.actions();
+      return this.resolvedActions;
     }
     return NOOP_ACTIONS_MOD;
   }
@@ -285,6 +296,7 @@ class Pipeline {
   }
 }
 export {
+  ALL_PIPELINE_FEATURES,
   Pipeline,
   PipelineFeatures
 };

package/dist/core/build/generate.js

@@ -187,13 +187,20 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
     const cpuCount = os.cpus().length;
     const assetsCreationPipeline = await prepareAssetsGenerationEnv(options, totalCount);
     const queue = new PQueue({ concurrency: Math.max(cpuCount, 1) });
+    const errors = [];
     const assetsTimer = performance.now();
     for (const [originalPath, transforms] of staticImageList) {
       queue.add(() => generateImagesForPath(originalPath, transforms, assetsCreationPipeline)).catch((e) => {
-        throw e;
+        logger.warn("build", `Unable to generate optimized image for ${originalPath}: ${e}`);
+        errors.push(new Error(`Error generating image for ${originalPath}: ${e}`, { cause: e }));
       });
     }
     await queue.onIdle();
+    if (errors.length === 1) {
+      throw errors[0];
+    } else if (errors.length > 1) {
+      throw new AggregateError(errors, `${errors.length} errors occurred during asset generation`);
+    }
     const assetsTimeEnd = performance.now();
     logger.info(null, colors.green(`\u2713 Completed in ${getTimeStat(assetsTimer, assetsTimeEnd)}.
 `));

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

@@ -9,16 +9,6 @@ interface BuildOptions {
      * @default false
      */
     devOutput?: boolean;
-    /**
-     * Teardown the compiler WASM instance after build. This can improve performance when
-     * building once, but may cause a performance hit if building multiple times in a row.
-     *
-     * When building multiple projects in the same execution (e.g. during tests), disabling
-     * this option can greatly improve performance at the cost of some extra memory usage.
-     *
-     * @default true
-     */
-    teardownCompiler?: boolean;
 }
 /**
  * Builds your site for deployment. By default, this will generate static files and place them in a dist/ directory.
@@ -50,7 +40,6 @@ export declare class AstroBuilder {
     private origin;
     private routesList;
     private timer;
-    private teardownCompiler;
     private sync;
     constructor(settings: AstroSettings, options: AstroBuilderOptions);
     /** Setup Vite and run any async setup logic that couldn't run inside of the constructor. */

package/dist/core/build/index.js

@@ -55,14 +55,12 @@ class AstroBuilder {
   origin;
   routesList;
   timer;
-  teardownCompiler;
   sync;
   constructor(settings, options) {
     this.mode = options.mode;
     this.runtimeMode = options.runtimeMode;
     this.settings = settings;
     this.logger = options.logger;
-    this.teardownCompiler = options.teardownCompiler ?? true;
     this.sync = options.sync ?? true;
     this.origin = settings.config.site ? new URL(settings.config.site).origin : `http://localhost:${settings.config.server.port}`;
     this.routesList = options.routesList ?? { routes: [] };
@@ -151,7 +149,6 @@ class AstroBuilder {
       runtimeMode: this.runtimeMode,
       origin: this.origin,
       pageNames,
-      teardownCompiler: this.teardownCompiler,
       viteConfig,
       key: keyPromise
     };

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

@@ -92,6 +92,13 @@ export interface BuildInternals {
         moduleIds: string[];
         prerender: boolean;
     }>;
+    /**
+     * Component exports that were rendered during the SSR build.
+     * Used by the client build's cssScopeTo recovery to distinguish between
+     * CSS that was tree-shaken because the component wasn't rendered in SSR
+     * vs CSS that was included in SSR.
+     */
+    ssrRenderedExports?: Map<string, Set<string>>;
 }
 /**
  * Creates internal maps used to coordinate the CSS and HTML plugins.

package/dist/core/build/plugins/plugin-chunk-imports.d.ts

@@ -6,5 +6,11 @@ import type { StaticBuildOptions } from '../types.js';
  * bypass the HTML rendering pipeline and miss skew protection query params.
  *
  * Uses es-module-lexer to reliably parse both static and dynamic imports.
+ *
+ * This runs in `generateBundle` (not `renderChunk`) so that Vite's CSS plugin
+ * can first remove pure-CSS wrapper chunks and replace their imports with
+ * `/* empty css * /` comments. If we rewrote imports earlier (in `renderChunk`),
+ * the appended query params would break Vite's regex-based CSS chunk cleanup,
+ * leaving dangling imports to deleted chunks that 404 at runtime.
  */
 export declare function pluginChunkImports(options: StaticBuildOptions): VitePlugin | undefined;

package/dist/core/build/plugins/plugin-chunk-imports.js

@@ -1,5 +1,17 @@
 import { init, parse } from "es-module-lexer";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+function getImportSpecifier(code, imp) {
+  if (imp.n != null) return imp.n;
+  if (imp.d > -1) {
+    const raw = code.slice(imp.s, imp.e);
+    const quote = raw[0];
+    if ((quote === "`" || quote === '"' || quote === "'") && raw.at(-1) === quote) {
+      const inner = raw.slice(1, -1);
+      if (!inner.includes("${")) return inner;
+    }
+  }
+  return void 0;
+}
 function pluginChunkImports(options) {
   const assetQueryParams = options.settings.adapter?.client?.assetQueryParams;
   if (!assetQueryParams || assetQueryParams.toString() === "") {
@@ -12,25 +24,25 @@ function pluginChunkImports(options) {
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
     },
-    async renderChunk(code, _chunk) {
-      if (!code.includes("./")) {
-        return null;
-      }
+    async generateBundle(_options, bundle) {
       await init;
-      const [imports] = parse(code);
-      const relativeImports = imports.filter(
-        (imp) => imp.n && /^\.\.?\//.test(imp.n) && /\.(?:js|mjs)$/.test(imp.n)
-      );
-      if (relativeImports.length === 0) {
-        return null;
-      }
-      let rewritten = code;
-      for (let i = relativeImports.length - 1; i >= 0; i--) {
-        const imp = relativeImports[i];
-        const insertAt = imp.d > -1 ? imp.e - 1 : imp.e;
-        rewritten = rewritten.slice(0, insertAt) + "?" + queryString + rewritten.slice(insertAt);
+      for (const [, chunk] of Object.entries(bundle)) {
+        if (chunk.type !== "chunk") continue;
+        if (!chunk.code.includes("./")) continue;
+        const [imports] = parse(chunk.code);
+        const relativeImports = imports.filter((imp) => {
+          const name = getImportSpecifier(chunk.code, imp);
+          return name != null && /^\.\.?\//.test(name) && /\.(?:js|mjs)$/.test(name);
+        });
+        if (relativeImports.length === 0) continue;
+        let rewritten = chunk.code;
+        for (let i = relativeImports.length - 1; i >= 0; i--) {
+          const imp = relativeImports[i];
+          const insertAt = imp.d > -1 ? imp.e - 1 : imp.e;
+          rewritten = rewritten.slice(0, insertAt) + "?" + queryString + rewritten.slice(insertAt);
+        }
+        chunk.code = rewritten;
       }
-      return { code: rewritten, map: null };
     }
   };
 }

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

@@ -46,10 +46,25 @@ function rollupPluginAstroBuildCSS(options) {
               internals.cssModuleToChunkIdMap.set(moduleId, chunk.fileName);
             }
           }
+          for (const [moduleId, moduleInfo] of Object.entries(chunk.modules || {})) {
+            if (moduleInfo.renderedExports.length > 0) {
+              const existing = internals.ssrRenderedExports?.get(moduleId);
+              if (existing) {
+                for (const exp of moduleInfo.renderedExports) {
+                  existing.add(exp);
+                }
+              } else {
+                internals.ssrRenderedExports ??= /* @__PURE__ */ new Map();
+                internals.ssrRenderedExports.set(moduleId, new Set(moduleInfo.renderedExports));
+              }
+            }
+          }
         }
       }
       const renderedComponentExports = /* @__PURE__ */ new Map();
       const componentToPages = /* @__PURE__ */ new Map();
+      const deletedCssAssets = /* @__PURE__ */ new Map();
+      const cssScopeToAddedCss = /* @__PURE__ */ new Set();
       if (this.environment?.name === ASTRO_VITE_ENVIRONMENT_NAMES.client) {
         for (const [, item] of Object.entries(bundle)) {
           if (item.type !== "chunk") continue;
@@ -76,6 +91,9 @@ function rollupPluginAstroBuildCSS(options) {
             );
             if (allCssInSSR && shouldDeleteCSSChunk(allModules, internals)) {
               for (const cssId of meta.importedCss) {
+                if (bundle[cssId]) {
+                  deletedCssAssets.set(cssId, bundle[cssId]);
+                }
                 delete bundle[cssId];
               }
             }
@@ -157,6 +175,14 @@ function rollupPluginAstroBuildCSS(options) {
                     }
                   }
                 }
+                const ssrExports = internals.ssrRenderedExports?.get(scopedToModule);
+                if (!ssrExports || !ssrExports.has(scopedToExport)) {
+                  for (const cssId of meta.importedCss) {
+                    if (deletedCssAssets.has(cssId)) {
+                      cssScopeToAddedCss.add(cssId);
+                    }
+                  }
+                }
               }
             }
           }
@@ -191,6 +217,13 @@ function rollupPluginAstroBuildCSS(options) {
           }
         }
       }
+      if (cssScopeToAddedCss.size > 0) {
+        for (const cssId of cssScopeToAddedCss) {
+          if (deletedCssAssets.has(cssId) && !bundle[cssId]) {
+            bundle[cssId] = deletedCssAssets.get(cssId);
+          }
+        }
+      }
     }
   };
   const singleCssPlugin = {

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

@@ -32,7 +32,7 @@ function pluginInternals(options, internals) {
           },
           resolve: {
             // Always bundle Astro runtime when building for SSR
-            noExternal: ["astro"]
+            noExternal: ["astro", "@astrojs/internal-helpers"]
           }
         };
       }