astro 5.4.2 → 5.5.0

package/client.d.ts

@@ -193,14 +193,14 @@ declare module 'astro:config/server' {
 	// biome-ignore format: bug
 	type ServerConfigSerialized = import('./dist/types/public/manifest.js').ServerDeserializedManifest;
 	const manifest: ServerConfigSerialized;
-	export default manifest;
+	export = manifest;
 }
 
 declare module 'astro:config/client' {
 	// biome-ignore format: bug
 	type ClientConfigSerialized = import('./dist/types/public/manifest.js').ClientDeserializedManifest;
 	const manifest: ClientConfigSerialized;
-	export default manifest;
+	export = manifest;
 }
 
 declare module 'astro:components' {

package/dist/assets/build/generate.js

@@ -170,6 +170,9 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env) {
         env.imageConfig
       )).data;
     } catch (e) {
+      if (AstroError.is(e)) {
+        throw e;
+      }
       const error = new AstroError(
         {
           ...AstroErrorData.CouldNotTransformImage,

package/dist/assets/utils/imageKind.d.ts

@@ -1,4 +1,22 @@
 import type { ImageMetadata, UnresolvedImageTransform } from '../types.js';
+/**
+ * Determines if the given source is an ECMAScript Module (ESM) imported image.
+ *
+ * @param {ImageMetadata | string} src - The source to check. It can be an `ImageMetadata` object or a string.
+ * @return {boolean} Returns `true` if the source is an `ImageMetadata` object, otherwise `false`.
+ */
 export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
+/**
+ * Determines if the provided source is a remote image URL in the form of a string.
+ *
+ * @param {ImageMetadata | string} src - The source to check, which can either be an `ImageMetadata` object or a string.
+ * @return {boolean} Returns `true` if the source is a string, otherwise `false`.
+ */
 export declare function isRemoteImage(src: ImageMetadata | string): src is string;
+/**
+ * Resolves the source of an image transformation by handling asynchronous or synchronous inputs.
+ *
+ * @param {UnresolvedImageTransform['src']} src - The source of the image transformation.
+ * @return {Promise<string | ImageMetadata>} A promise that resolves to the image source. It returns either the default export of the resolved source or the resolved source itself if the default export doesn't exist.
+ */
 export declare function resolveSrc(src: UnresolvedImageTransform['src']): Promise<string | ImageMetadata>;

package/dist/assets/utils/imageKind.js

@@ -5,7 +5,11 @@ function isRemoteImage(src) {
   return typeof src === "string";
 }
 async function resolveSrc(src) {
-  return typeof src === "object" && "then" in src ? (await src).default ?? await src : src;
+  if (typeof src === "object" && "then" in src) {
+    const resource = await src;
+    return resource.default ?? resource;
+  }
+  return src;
 }
 export {
   isESMImportedImage,

package/dist/assets/utils/index.d.ts

@@ -1,8 +1,13 @@
+/**
+ * NOTE: this is a public module exposed to the user, so all functions exposed
+ * here must be documented via JsDoc and in the docs website.
+ *
+ * If some functions don't need to be exposed, just import the file that contains the functions.
+ */
 export { emitESMImage } from './node/emitAsset.js';
 export { isESMImportedImage, isRemoteImage } from './imageKind.js';
 export { imageMetadata } from './metadata.js';
 export { getOrigQueryParams } from './queryParams.js';
 export { hashTransform, propsToFilename } from './transformToPath.js';
 export { inferRemoteSize } from './remoteProbe.js';
-export { makeSvgComponent } from './svg.js';
 export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from './remotePattern.js';

package/dist/assets/utils/index.js

@@ -4,7 +4,6 @@ import { imageMetadata } from "./metadata.js";
 import { getOrigQueryParams } from "./queryParams.js";
 import { hashTransform, propsToFilename } from "./transformToPath.js";
 import { inferRemoteSize } from "./remoteProbe.js";
-import { makeSvgComponent } from "./svg.js";
 import {
   isRemoteAllowed,
   matchHostname,
@@ -22,7 +21,6 @@ export {
   isESMImportedImage,
   isRemoteAllowed,
   isRemoteImage,
-  makeSvgComponent,
   matchHostname,
   matchPathname,
   matchPattern,

package/dist/assets/utils/metadata.d.ts

@@ -1,2 +1,10 @@
 import type { ImageMetadata } from '../types.js';
+/**
+ * Extracts image metadata such as dimensions, format, and orientation from the provided image data.
+ *
+ * @param {Uint8Array} data - The binary data of the image.
+ * @param {string} [src] - The source path or URL of the image, used for error messages. Optional.
+ * @return {Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>} A promise that resolves with the extracted metadata, excluding `src` and `fsPath`.
+ * @throws {AstroError} Throws an error if the image metadata cannot be extracted.
+ */
 export declare function imageMetadata(data: Uint8Array, src?: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

package/dist/assets/utils/metadata.js

@@ -1,28 +1,29 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { lookup as probe } from "../utils/vendor/image-size/lookup.js";
 async function imageMetadata(data, src) {
+  let result;
   try {
-    const result = probe(data);
-    if (!result.height || !result.width || !result.type) {
-      throw new AstroError({
-        ...AstroErrorData.NoImageMetadata,
-        message: AstroErrorData.NoImageMetadata.message(src)
-      });
-    }
-    const { width, height, type, orientation } = result;
-    const isPortrait = (orientation || 0) >= 5;
-    return {
-      width: isPortrait ? height : width,
-      height: isPortrait ? width : height,
-      format: type,
-      orientation
-    };
+    result = probe(data);
   } catch {
     throw new AstroError({
       ...AstroErrorData.NoImageMetadata,
       message: AstroErrorData.NoImageMetadata.message(src)
     });
   }
+  if (!result.height || !result.width || !result.type) {
+    throw new AstroError({
+      ...AstroErrorData.NoImageMetadata,
+      message: AstroErrorData.NoImageMetadata.message(src)
+    });
+  }
+  const { width, height, type, orientation } = result;
+  const isPortrait = (orientation || 0) >= 5;
+  return {
+    width: isPortrait ? height : width,
+    height: isPortrait ? width : height,
+    format: type,
+    orientation
+  };
 }
 export {
   imageMetadata

package/dist/assets/utils/node/emitAsset.d.ts

@@ -4,6 +4,15 @@ type FileEmitter = vite.Rollup.EmitFile;
 type ImageMetadataWithContents = ImageMetadata & {
     contents?: Buffer;
 };
+/**
+ * Processes an image file and emits its metadata and optionally its contents. This function supports both build and development modes.
+ *
+ * @param {string | undefined} id - The identifier or path of the image file to process. If undefined, the function returns immediately.
+ * @param {boolean} _watchMode - **Deprecated**: Indicates if the method is operating in watch mode. This parameter will be removed or updated in the future.
+ * @param {boolean} experimentalSvgEnabled - A flag to enable experimental handling of SVG files. Embeds SVG file data if set to true.
+ * @param {FileEmitter | undefined} [fileEmitter] - Function for emitting files during the build process. May throw in certain scenarios.
+ * @return {Promise<ImageMetadataWithContents | undefined>} Resolves to metadata with optional image contents or `undefined` if processing fails.
+ */
 export declare function emitESMImage(id: string | undefined, 
 /** @deprecated */
 _watchMode: boolean, experimentalSvgEnabled: boolean, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;

package/dist/assets/utils/node/emitAsset.js

@@ -24,7 +24,7 @@ async function emitESMImage(id, _watchMode, experimentalSvgEnabled, fileEmitter)
     writable: false,
     value: id
   });
-  if (fileMetadata.format === "svg" && experimentalSvgEnabled === true) {
+  if (fileMetadata.format === "svg" && experimentalSvgEnabled) {
     emittedImage.contents = fileData;
   }
   let isBuild = typeof fileEmitter === "function";

package/dist/assets/utils/queryParams.d.ts

@@ -1,2 +1,11 @@
 import type { ImageMetadata } from '../types.js';
+/**
+ * Extracts the original image query parameters (width, height, format) from the given `URLSearchParams` object
+ * and returns them as an object. If any of the required parameters are missing or invalid, the function returns undefined.
+ *
+ * The `width` and `height` are parsed to integer values.
+ *
+ * @param {URLSearchParams} params - The `URLSearchParams` object containing the query parameters.
+ * @return {Pick<ImageMetadata, 'width' | 'height' | 'format'> | undefined} An object with the original image parameters (width, height, format) or undefined if any parameter is missing.
+ */
 export declare function getOrigQueryParams(params: URLSearchParams): Pick<ImageMetadata, 'width' | 'height' | 'format'> | undefined;

package/dist/assets/utils/remoteProbe.d.ts

@@ -1,2 +1,9 @@
 import type { ImageMetadata } from '../types.js';
+/**
+ * Infers the dimensions of a remote image by streaming its data and analyzing it progressively until sufficient metadata is available.
+ *
+ * @param {string} url - The URL of the remote image from which to infer size metadata.
+ * @return {Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>} Returns a promise that resolves to an object containing the image dimensions metadata excluding `src` and `fsPath`.
+ * @throws {AstroError} Thrown when the fetching fails or metadata cannot be extracted.
+ */
 export declare function inferRemoteSize(url: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

package/dist/assets/utils/transformToPath.d.ts

@@ -1,3 +1,33 @@
 import type { ImageTransform } from '../types.js';
+/**
+ * Converts a file path and transformation properties of the transformation image service, into a formatted filename.
+ *
+ * The formatted filename follows this structure:
+ *
+ * `<prefixDirname>/<baseFilename>_<hash><outputExtension>`
+ *
+ * - `prefixDirname`: If the image is an ESM imported image, this is the directory name of the original file path; otherwise, it will be an empty string.
+ * - `baseFilename`: The base name of the file or a hashed short name if the file is a `data:` URI.
+ * - `hash`: A unique hash string generated to distinguish the transformed file.
+ * - `outputExtension`: The desired output file extension derived from the `transform.format` or the original file extension.
+ *
+ * ## Example
+ * - Input: `filePath = '/images/photo.jpg'`, `transform = { format: 'png', src: '/images/photo.jpg' }`, `hash = 'abcd1234'`.
+ * - Output: `/images/photo_abcd1234.png`
+ *
+ * @param {string} filePath - The original file path or data URI of the source image.
+ * @param {ImageTransform} transform - An object representing the transformation properties, including format and source.
+ * @param {string} hash - A unique hash used to differentiate the transformed file.
+ * @return {string} The generated filename based on the provided input, transformations, and hash.
+ */
 export declare function propsToFilename(filePath: string, transform: ImageTransform, hash: string): string;
+/**
+ * Transforms the provided `transform` object into a hash string based on selected properties
+ * and the specified `imageService`.
+ *
+ * @param {ImageTransform} transform - The transform object containing various image transformation properties.
+ * @param {string} imageService - The name of the image service related to the transform.
+ * @param {string[]} propertiesToHash - An array of property names from the `transform` object that should be used to generate the hash.
+ * @return {string} A hashed string created from the specified properties of the `transform` object and the image service.
+ */
 export declare function hashTransform(transform: ImageTransform, imageService: string, propertiesToHash: string[]): string;

package/dist/cli/add/index.js

@@ -6,7 +6,7 @@ import { diffWords } from "diff";
 import { bold, cyan, dim, green, magenta, red, yellow } from "kleur/colors";
 import { builders, generateCode, loadFile } from "magicast";
 import { getDefaultExportOptions } from "magicast/helpers";
-import preferredPM from "preferred-pm";
+import { detect, resolveCommand } from "package-manager-detector";
 import prompts from "prompts";
 import maxSatisfying from "semver/ranges/max-satisfying.js";
 import yoctoSpinner from "yocto-spinner";
@@ -190,7 +190,7 @@ async function add(names, { flags }) {
           logger.debug("add", `Using existing db configuration`);
         }
       }
-      if (integrations.find((integration) => integration.id === "lit") && (await preferredPM(fileURLToPath(root)))?.name === "pnpm") {
+      if (integrations.find((integration) => integration.id === "lit") && (await detect({ cwd: fileURLToPath(root) }))?.name === "pnpm") {
         await setupIntegrationConfig({
           root,
           logger,
@@ -494,28 +494,6 @@ ${message}`
     return 2 /* cancelled */;
   }
 }
-async function getInstallIntegrationsCommand({
-  integrations,
-  logger,
-  cwd = process.cwd()
-}) {
-  const pm = await preferredPM(cwd);
-  logger.debug("add", `package manager: ${JSON.stringify(pm)}`);
-  if (!pm) return null;
-  const dependencies = await convertIntegrationsToInstallSpecifiers(integrations);
-  switch (pm.name) {
-    case "npm":
-      return { pm: "npm", command: "install", flags: [], dependencies };
-    case "yarn":
-      return { pm: "yarn", command: "add", flags: [], dependencies };
-    case "pnpm":
-      return { pm: "pnpm", command: "add", flags: [], dependencies };
-    case "bun":
-      return { pm: "bun", command: "add", flags: [], dependencies };
-    default:
-      return null;
-  }
-}
 async function convertIntegrationsToInstallSpecifiers(integrations) {
   const ranges = {};
   for (let { dependencies } of integrations) {
@@ -550,7 +528,14 @@ async function tryToInstallIntegrations({
   flags,
   logger
 }) {
-  const installCommand = await getInstallIntegrationsCommand({ integrations, cwd, logger });
+  const packageManager = await detect({
+    cwd,
+    // Include the `install-metadata` strategy to have the package manager that's
+    // used for installation take precedence
+    strategies: ["install-metadata", "lockfile", "packageManager-field"]
+  });
+  logger.debug("add", `package manager: "${packageManager?.name}"`);
+  if (!packageManager) return 0 /* none */;
   const inheritedFlags = Object.entries(flags).map(([flag]) => {
     if (flag == "_") return;
     if (INHERITED_FLAGS.has(flag)) {
@@ -558,60 +543,46 @@ async function tryToInstallIntegrations({
       return `--${flag}`;
     }
   }).filter(Boolean).flat();
-  if (installCommand === null) {
-    return 0 /* none */;
-  } else {
-    const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command}${[
-      "",
-      ...installCommand.flags,
-      ...inheritedFlags
-    ].join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
-    const message = `
+  const installCommand = resolveCommand(packageManager?.agent ?? "npm", "add", inheritedFlags);
+  if (!installCommand) return 0 /* none */;
+  const installSpecifiers = await convertIntegrationsToInstallSpecifiers(integrations);
+  const coloredOutput = `${bold(installCommand.command)} ${installCommand.args.join(" ")} ${cyan(installSpecifiers.join(" "))}`;
+  const message = `
 ${boxen(coloredOutput, {
-      margin: 0.5,
-      padding: 0.5,
-      borderStyle: "round"
-    })}
+    margin: 0.5,
+    padding: 0.5,
+    borderStyle: "round"
+  })}
 `;
-    logger.info(
-      "SKIP_FORMAT",
-      `
+  logger.info(
+    "SKIP_FORMAT",
+    `
   ${magenta("Astro will run the following command:")}
   ${dim(
-        "If you skip this step, you can always run it yourself later"
-      )}
+      "If you skip this step, you can always run it yourself later"
+    )}
 ${message}`
-    );
-    if (await askToContinue({ flags })) {
-      const spinner = yoctoSpinner({ text: "Installing dependencies..." }).start();
-      try {
-        await exec(
-          installCommand.pm,
-          [
-            installCommand.command,
-            ...installCommand.flags,
-            ...inheritedFlags,
-            ...installCommand.dependencies
-          ],
-          {
-            nodeOptions: {
-              cwd,
-              // reset NODE_ENV to ensure install command run in dev mode
-              env: { NODE_ENV: void 0 }
-            }
-          }
-        );
-        spinner.success();
-        return 1 /* updated */;
-      } catch (err) {
-        spinner.error();
-        logger.debug("add", "Error installing dependencies", err);
-        console.error("\n", err.stdout || err.message, "\n");
-        return 3 /* failure */;
-      }
-    } else {
-      return 2 /* cancelled */;
+  );
+  if (await askToContinue({ flags })) {
+    const spinner = yoctoSpinner({ text: "Installing dependencies..." }).start();
+    try {
+      await exec(installCommand.command, [...installCommand.args, ...installSpecifiers], {
+        nodeOptions: {
+          cwd,
+          // reset NODE_ENV to ensure install command run in dev mode
+          env: { NODE_ENV: void 0 }
+        }
+      });
+      spinner.success();
+      return 1 /* updated */;
+    } catch (err) {
+      spinner.error();
+      logger.debug("add", "Error installing dependencies", err);
+      console.error("\n", err.stdout || err.message, "\n");
+      return 3 /* failure */;
     }
+  } else {
+    return 2 /* cancelled */;
   }
 }
 async function validateIntegrations(integrations) {

package/dist/cli/install-package.d.ts

@@ -5,12 +5,6 @@ type GetPackageOptions = {
     cwd?: string;
 };
 export declare function getPackage<T>(packageName: string, logger: Logger, options: GetPackageOptions, otherDeps?: string[]): Promise<T | undefined>;
-/**
- * Get the command to execute and download a package (e.g. `npx`, `yarn dlx`, `pnpm dlx`, etc.)
- * @param packageManager - Optional package manager to use. If not provided, Astro will attempt to detect the preferred package manager.
- * @returns The command to execute and download a package
- */
-export declare function getExecCommand(packageManager?: string): Promise<string>;
 export declare function fetchPackageJson(scope: string | undefined, name: string, tag: string): Promise<Record<string, any> | Error>;
 export declare function fetchPackageVersions(packageName: string): Promise<string[] | Error>;
 export {};

package/dist/cli/install-package.js

@@ -2,9 +2,8 @@ import { createRequire } from "node:module";
 import boxen from "boxen";
 import ci from "ci-info";
 import { bold, cyan, dim, magenta } from "kleur/colors";
-import preferredPM from "preferred-pm";
+import { detect, resolveCommand } from "package-manager-detector";
 import prompts from "prompts";
-import whichPm from "which-pm";
 import yoctoSpinner from "yocto-spinner";
 import { exec } from "./exec.js";
 const require2 = createRequire(import.meta.url);
@@ -34,48 +33,17 @@ async function getPackage(packageName, logger, options, otherDeps = []) {
     }
   }
 }
-function getInstallCommand(packages, packageManager) {
-  switch (packageManager) {
-    case "npm":
-      return { pm: "npm", command: "install", flags: [], dependencies: packages };
-    case "yarn":
-      return { pm: "yarn", command: "add", flags: [], dependencies: packages };
-    case "pnpm":
-      return { pm: "pnpm", command: "add", flags: [], dependencies: packages };
-    case "bun":
-      return { pm: "bun", command: "add", flags: [], dependencies: packages };
-    default:
-      return null;
-  }
-}
-async function getExecCommand(packageManager) {
-  if (!packageManager) {
-    packageManager = (await preferredPM(process.cwd()))?.name ?? "npm";
-  }
-  switch (packageManager) {
-    case "npm":
-      return "npx";
-    case "yarn":
-      return "yarn dlx";
-    case "pnpm":
-      return "pnpm dlx";
-    case "bun":
-      return "bunx";
-    default:
-      return "npx";
-  }
-}
 async function installPackage(packageNames, options, logger) {
   const cwd = options.cwd ?? process.cwd();
-  const packageManager = (await whichPm(cwd))?.name ?? "npm";
-  const installCommand = getInstallCommand(packageNames, packageManager);
-  if (!installCommand) {
-    return false;
-  }
-  const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command}${[
-    "",
-    ...installCommand.flags
-  ].join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
+  const packageManager = await detect({
+    cwd,
+    // Include the `install-metadata` strategy to have the package manager that's
+    // used for installation take precedence
+    strategies: ["install-metadata", "lockfile", "packageManager-field"]
+  });
+  const installCommand = resolveCommand(packageManager?.agent ?? "npm", "add", []);
+  if (!installCommand) return false;
+  const coloredOutput = `${bold(installCommand.command)} ${installCommand.args.join(" ")} ${cyan(packageNames.join(" "))}`;
   const message = `
 ${boxen(coloredOutput, {
     margin: 0.5,
@@ -106,17 +74,13 @@ ${message}`
   if (Boolean(response)) {
     const spinner = yoctoSpinner({ text: "Installing dependencies..." }).start();
     try {
-      await exec(
-        installCommand.pm,
-        [installCommand.command, ...installCommand.flags, ...installCommand.dependencies],
-        {
-          nodeOptions: {
-            cwd,
-            // reset NODE_ENV to ensure install command run in dev mode
-            env: { NODE_ENV: void 0 }
-          }
+      await exec(installCommand.command, [...installCommand.args, ...packageNames], {
+        nodeOptions: {
+          cwd,
+          // reset NODE_ENV to ensure install command run in dev mode
+          env: { NODE_ENV: void 0 }
         }
-      );
+      });
       spinner.success();
       return true;
     } catch (err) {
@@ -157,7 +121,7 @@ let _registry;
 async function getRegistry() {
   if (_registry) return _registry;
   const fallback = "https://registry.npmjs.org";
-  const packageManager = (await preferredPM(process.cwd()))?.name || "npm";
+  const packageManager = (await detect())?.name || "npm";
   try {
     const { stdout } = await exec(packageManager, ["config", "get", "registry"]);
     _registry = stdout.trim()?.replace(/\/$/, "") || fallback;
@@ -170,6 +134,5 @@ async function getRegistry() {
 export {
   fetchPackageJson,
   fetchPackageVersions,
-  getExecCommand,
   getPackage
 };

package/dist/content/content-layer.js

@@ -153,7 +153,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.4.2") {
+    if (previousAstroVersion && previousAstroVersion !== "5.5.0") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -161,8 +161,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.4.2") {
-      await this.#store.metaStore().set("astro-version", "5.4.2");
+    if ("5.5.0") {
+      await this.#store.metaStore().set("astro-version", "5.5.0");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);

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

@@ -101,22 +101,6 @@ function rollupPluginAstroBuildCSS(options) {
       }
     }
   };
-  const cssScopeToPlugin = {
-    name: "astro:rollup-plugin-css-scope-to",
-    renderChunk(_, chunk, __, meta) {
-      for (const id in chunk.modules) {
-        const modMeta = this.getModuleInfo(id)?.meta;
-        const cssScopeTo = modMeta?.astroCss?.cssScopeTo;
-        if (cssScopeTo && !isCssScopeToRendered(cssScopeTo, Object.values(meta.chunks))) {
-          delete chunk.modules[id];
-          const moduleIdsIndex = chunk.moduleIds.indexOf(id);
-          if (moduleIdsIndex > -1) {
-            chunk.moduleIds.splice(moduleIdsIndex, 1);
-          }
-        }
-      }
-    }
-  };
   const singleCssPlugin = {
     name: "astro:rollup-plugin-single-css",
     enforce: "post",
@@ -178,7 +162,7 @@ function rollupPluginAstroBuildCSS(options) {
       });
     }
   };
-  return [cssBuildPlugin, cssScopeToPlugin, singleCssPlugin, inlineStylesheetsPlugin];
+  return [cssBuildPlugin, singleCssPlugin, inlineStylesheetsPlugin];
 }
 function* getParentClientOnlys(id, ctx, internals) {
   for (const info of getParentModuleInfos(id, ctx)) {
@@ -203,16 +187,6 @@ function appendCSSToPage(pageData, meta, pagesToCss, depth, order) {
     }
   }
 }
-function isCssScopeToRendered(cssScopeTo, chunks) {
-  for (const moduleId in cssScopeTo) {
-    const exports = cssScopeTo[moduleId];
-    const renderedModule = chunks.find((c) => c.moduleIds.includes(moduleId))?.modules[moduleId];
-    if (renderedModule?.renderedExports.some((e) => exports.includes(e))) {
-      return true;
-    }
-  }
-  return false;
-}
 export {
   pluginCSS
 };

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

@@ -137,7 +137,15 @@ async function ssrBuild(opts, internals, input, container) {
             const encoded = encodeName(name);
             return [prefix, encoded, suffix].join("");
           },
-          assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
+          assetFileNames(chunkInfo) {
+            const { names } = chunkInfo;
+            const name = 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(ASTRO_PAGE_RESOLVED_MODULE_ID)) {

package/dist/core/compile/compile.js

@@ -35,6 +35,7 @@ async function compile({
         cssPartialCompileResults,
         cssTransformErrors
       }),
+      experimentalScriptOrder: astroConfig.experimental.preserveScriptOrder ?? false,
       async resolvePath(specifier) {
         return resolvePath(specifier, filename);
       }