astro 2.1.9 → 2.2.1

package/client-base.d.ts

@@ -178,6 +178,10 @@ declare module '*.module.pcss' {
 	const classes: CSSModuleClasses;
 	export default classes;
 }
+declare module '*.module.sss' {
+	const classes: CSSModuleClasses;
+	export default classes;
+}
 
 // CSS
 declare module '*.css' {
@@ -208,9 +212,31 @@ declare module '*.pcss' {
 	const css: string;
 	export default css;
 }
+declare module '*.sss' {
+	const css: string;
+	export default css;
+}
 
 // Built-in asset types
-// see `src/constants.ts`
+// see `src/node/constants.ts`
+
+// images
+declare module '*.jfif' {
+	const src: string;
+	export default src;
+}
+declare module '*.pjpeg' {
+	const src: string;
+	export default src;
+}
+declare module '*.pjp' {
+	const src: string;
+	export default src;
+}
+declare module '*.ico' {
+	const src: string;
+	export default src;
+}
 
 // media
 declare module '*.mp4' {
@@ -242,6 +268,11 @@ declare module '*.aac' {
 	export default src;
 }
 
+declare module '*.opus' {
+	const src: string;
+	export default src;
+}
+
 // fonts
 declare module '*.woff' {
 	const src: string;
@@ -265,10 +296,6 @@ declare module '*.otf' {
 }
 
 // other
-declare module '*.wasm' {
-	const initWasm: (options: WebAssembly.Imports) => Promise<WebAssembly.Exports>;
-	export default initWasm;
-}
 declare module '*.webmanifest' {
 	const src: string;
 	export default src;
@@ -282,6 +309,12 @@ declare module '*.txt' {
 	export default src;
 }
 
+// wasm?init
+declare module '*.wasm?init' {
+	const initWasm: (options: WebAssembly.Imports) => Promise<WebAssembly.Instance>;
+	export default initWasm;
+}
+
 // web worker
 declare module '*?worker' {
 	const workerConstructor: {
@@ -297,6 +330,11 @@ declare module '*?worker&inline' {
 	export default workerConstructor;
 }
 
+declare module '*?worker&url' {
+	const src: string;
+	export default src;
+}
+
 declare module '*?sharedworker' {
 	const sharedWorkerConstructor: {
 		new (): SharedWorker;
@@ -304,6 +342,18 @@ declare module '*?sharedworker' {
 	export default sharedWorkerConstructor;
 }
 
+declare module '*?sharedworker&inline' {
+	const sharedWorkerConstructor: {
+		new (): SharedWorker;
+	};
+	export default sharedWorkerConstructor;
+}
+
+declare module '*?sharedworker&url' {
+	const src: string;
+	export default src;
+}
+
 declare module '*?raw' {
 	const src: string;
 	export default src;

package/config.d.ts

@@ -1,4 +1,5 @@
 type ViteUserConfig = import('vite').UserConfig;
+type ViteUserConfigFn = import('vite').UserConfigFn;
 type AstroUserConfig = import('./dist/@types/astro.js').AstroUserConfig;
 
 /**
@@ -10,4 +11,4 @@ export function defineConfig(config: AstroUserConfig): AstroUserConfig;
 /**
  * Use Astro to generate a fully resolved Vite config
  */
-export function getViteConfig(config: ViteUserConfig): ViteUserConfig;
+export function getViteConfig(config: ViteUserConfig): ViteUserConfigFn;

package/dist/@types/astro.d.ts

@@ -18,8 +18,8 @@ import type { LogOptions } from '../core/logger/core';
 import type { AstroComponentFactory, AstroComponentInstance } from '../runtime/server';
 import type { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from './../core/constants.js';
 export type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, ShikiConfig, } from '@astrojs/markdown-remark';
-export type { ExternalImageService, LocalImageService } from '../assets/services/service';
-export type { ImageMetadata, ImageTransform } from '../assets/types';
+export type { ExternalImageService, ImageService, LocalImageService, } from '../assets/services/service';
+export type { GetImageResult, ImageInputFormat, ImageMetadata, ImageOutputFormat, ImageQuality, ImageQualityPreset, ImageTransform, } from '../assets/types';
 export type { SSRManifest } from '../core/app/types';
 export type { AstroCookies } from '../core/cookies';
 export interface AstroBuiltinProps {
@@ -568,6 +568,29 @@ export interface AstroUserConfig {
          * ```
          */
         assets?: string;
+        /**
+         * @docs
+         * @name build.assetsPrefix
+         * @type {string}
+         * @default `undefined`
+         * @version 2.2.0
+         * @description
+         * Specifies the prefix for Astro-generated asset links. This can be used if assets are served from a different domain than the current site.
+         *
+         * For example, if this is set to `https://cdn.example.com`, assets will be fetched from `https://cdn.example.com/_astro/...` (regardless of the `base` option).
+         * You would need to upload the files in `./dist/_astro/` to `https://cdn.example.com/_astro/` to serve the assets.
+         * The process varies depending on how the third-party domain is hosted.
+         * To rename the `_astro` path, specify a new directory in `build.assets`.
+         *
+         * ```js
+         * {
+         *   build: {
+         *     assetsPrefix: 'https://cdn.example.com'
+         *   }
+         * }
+         * ```
+         */
+        assetsPrefix?: string;
         /**
          * @docs
          * @name build.serverEntry

package/dist/assets/image-endpoint.js

@@ -1,4 +1,4 @@
-import mime from "mime";
+import mime from "mime/lite.js";
 import { isRemotePath } from "../core/path.js";
 import { getConfiguredImageService } from "./internal.js";
 import { isLocalService } from "./services/service.js";
@@ -35,7 +35,7 @@ const get = async ({ request }) => {
     return new Response(data, {
       status: 200,
       headers: {
-        "Content-Type": mime.getType(format) || "",
+        "Content-Type": mime.getType(format) ?? `image/${format}`,
         "Cache-Control": "public, max-age=31536000",
         ETag: etag(data.toString()),
         Date: (/* @__PURE__ */ new Date()).toUTCString()

package/dist/assets/index.d.ts

@@ -1,5 +1,5 @@
 export { getConfiguredImageService, getImage } from './internal.js';
-export { baseService } from './services/service.js';
+export { baseService, isLocalService } from './services/service.js';
 export { type LocalImageProps, type RemoteImageProps } from './types.js';
 export { emitESMImage } from './utils/emitAsset.js';
 export { imageMetadata } from './utils/metadata.js';

package/dist/assets/index.js

@@ -1,5 +1,5 @@
 import { getConfiguredImageService, getImage } from "./internal.js";
-import { baseService } from "./services/service.js";
+import { baseService, isLocalService } from "./services/service.js";
 import {} from "./types.js";
 import { emitESMImage } from "./utils/emitAsset.js";
 import { imageMetadata } from "./utils/metadata.js";
@@ -8,5 +8,6 @@ export {
   emitESMImage,
   getConfiguredImageService,
   getImage,
-  imageMetadata
+  imageMetadata,
+  isLocalService
 };

package/dist/assets/internal.d.ts

@@ -1,14 +1,8 @@
 import type { StaticBuildOptions } from '../core/build/types.js';
 import { type ImageService } from './services/service.js';
-import type { ImageMetadata, ImageTransform } from './types.js';
+import type { GetImageResult, ImageMetadata, ImageTransform } from './types.js';
 export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
 export declare function getConfiguredImageService(): Promise<ImageService>;
-interface GetImageResult {
-    rawOptions: ImageTransform;
-    options: ImageTransform;
-    src: string;
-    attributes: Record<string, any>;
-}
 /**
  * Get an optimized image and the necessary attributes to render it.
  *
@@ -18,7 +12,7 @@ interface GetImageResult {
  * import { getImage } from 'astro:assets';
  * import originalImage from '../assets/image.png';
  *
- * const optimizedImage = await getImage({src: originalImage, width: 1280 })
+ * const optimizedImage = await getImage({src: originalImage, width: 1280 });
  * ---
  * <img src={optimizedImage.src} {...optimizedImage.attributes} />
  * ```

package/dist/assets/services/service.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { ImageTransform, OutputFormat } from '../types.js';
+import type { ImageOutputFormat, ImageTransform } from '../types.js';
 export type ImageService = LocalImageService | ExternalImageService;
 export declare function isLocalService(service: ImageService | undefined): service is LocalImageService;
 export declare function parseQuality(quality: string): string | number;
@@ -48,7 +48,7 @@ export interface LocalImageService extends SharedServiceProps {
      */
     transform: (inputBuffer: Buffer, transform: LocalImageTransform) => Promise<{
         data: Buffer;
-        format: OutputFormat;
+        format: ImageOutputFormat;
     }>;
 }
 export type BaseServiceTransform = {

package/dist/assets/services/vendor/squoosh/image-pool.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="node" />
-import type { OutputFormat } from '../../../types.js';
+import type { ImageOutputFormat } from '../../../types.js';
 import type { Operation } from './image.js';
-export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: OutputFormat, quality?: number): Promise<Uint8Array>;
+export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: ImageOutputFormat, quality?: number): Promise<Uint8Array>;

package/dist/assets/services/vendor/squoosh/image.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { OutputFormat } from '../../../types.js';
+import type { ImageOutputFormat } from '../../../types.js';
 type RotateOperation = {
     type: 'rotate';
     numRotations: number;
@@ -10,5 +10,5 @@ type ResizeOperation = {
     height?: number;
 };
 export type Operation = RotateOperation | ResizeOperation;
-export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: OutputFormat, quality?: number): Promise<Uint8Array>;
+export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: ImageOutputFormat, quality?: number): Promise<Uint8Array>;
 export {};

package/dist/assets/types.d.ts

@@ -2,8 +2,8 @@ import type { VALID_INPUT_FORMATS, VALID_OUTPUT_FORMATS } from './consts.js';
 import type { ImageService } from './services/service.js';
 export type ImageQualityPreset = 'low' | 'mid' | 'high' | 'max' | (string & {});
 export type ImageQuality = ImageQualityPreset | number;
-export type InputFormat = (typeof VALID_INPUT_FORMATS)[number] | 'svg';
-export type OutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
+export type ImageInputFormat = (typeof VALID_INPUT_FORMATS)[number] | 'svg';
+export type ImageOutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
 declare global {
     var astroAsset: {
         imageService?: ImageService;
@@ -21,19 +21,25 @@ export interface ImageMetadata {
     src: string;
     width: number;
     height: number;
-    format: InputFormat;
+    format: ImageInputFormat;
 }
 /**
  * Options accepted by the image transformation service.
  */
 export type ImageTransform = {
     src: ImageMetadata | string;
-    width?: number;
-    height?: number;
-    quality?: ImageQuality;
-    format?: OutputFormat;
+    width?: number | undefined;
+    height?: number | undefined;
+    quality?: ImageQuality | undefined;
+    format?: ImageOutputFormat | undefined;
     [key: string]: any;
 };
+export interface GetImageResult {
+    rawOptions: ImageTransform;
+    options: ImageTransform;
+    src: string;
+    attributes: Record<string, any>;
+}
 type WithRequired<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
 };
@@ -91,11 +97,11 @@ export type LocalImageProps<T> = ImageSharedProps<T> & {
      * <Image src={...} format="avif" alt="..." />
      * ```
      */
-    format?: OutputFormat;
+    format?: ImageOutputFormat;
     /**
      * Desired quality for the image. Value can either be a preset such as `low` or `high`, or a numeric value from 0 to 100.
      *
-     * The perceptual quality of the output image is loader-specific.
+     * The perceptual quality of the output image is service-specific.
      * For instance, a certain service might decide that `high` results in a very beautiful image, but another could choose for it to be at best passable.
      *
      * **Example**:

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

@@ -1,3 +1,4 @@
 import type { AstroSettings } from '../../@types/astro';
-export declare function emitESMImage(id: string, watchMode: boolean, fileEmitter: any, settings: Pick<AstroSettings, 'config'>): Promise<import("./metadata.js").Metadata | undefined>;
+import { type Metadata } from './metadata.js';
+export declare function emitESMImage(id: string | undefined, watchMode: boolean, fileEmitter: any, settings: Pick<AstroSettings, 'config'>): Promise<Metadata | undefined>;
 export declare function emoji(char: string, fallback: string): string;

package/dist/assets/utils/emitAsset.js

@@ -4,10 +4,13 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import slash from "slash";
 import { imageMetadata } from "./metadata.js";
 async function emitESMImage(id, watchMode, fileEmitter, settings) {
+  if (!id) {
+    return void 0;
+  }
   const url = pathToFileURL(id);
   const meta = await imageMetadata(url);
   if (!meta) {
-    return;
+    return void 0;
   }
   if (!watchMode) {
     const pathname = decodeURI(url.pathname);

package/dist/assets/vite-plugin-assets.js

@@ -1,12 +1,12 @@
 import { bold } from "kleur/colors";
 import MagicString from "magic-string";
-import mime from "mime";
+import mime from "mime/lite.js";
 import fs from "node:fs/promises";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { normalizePath } from "vite";
 import { error } from "../core/logger/core.js";
-import { joinPaths, prependForwardSlash } from "../core/path.js";
+import { appendForwardSlash, joinPaths, prependForwardSlash } from "../core/path.js";
 import { VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
 import { isESMImportedImage } from "./internal.js";
 import { isLocalService } from "./services/service.js";
@@ -69,7 +69,7 @@ function assets({
       load(id) {
         if (id === resolvedVirtualModuleId) {
           return `
-					export { getImage, getConfiguredImageService } from "astro/assets";
+					export { getImage, getConfiguredImageService, isLocalService } from "astro/assets";
 					export { default as Image } from "astro/components/Image.astro";
 				`;
         }
@@ -107,10 +107,7 @@ function assets({
               data = result.data;
               format = result.format;
             }
-            res.setHeader(
-              "Content-Type",
-              mime.getType(fileURLToPath(filePathURL)) || `image/${format}`
-            );
+            res.setHeader("Content-Type", mime.getType(format) ?? `image/${format}`);
             res.setHeader("Cache-Control", "max-age=360000");
             const stream = Readable.from(data);
             return stream.pipe(res);
@@ -139,7 +136,11 @@ function assets({
             );
             globalThis.astroAsset.staticImages.set(hash, { path: filePath, options });
           }
-          return prependForwardSlash(joinPaths(settings.config.base, filePath));
+          if (settings.config.build.assetsPrefix) {
+            return joinPaths(settings.config.build.assetsPrefix, filePath);
+          } else {
+            return prependForwardSlash(joinPaths(settings.config.base, filePath));
+          }
         };
       },
       async buildEnd() {
@@ -160,7 +161,8 @@ function assets({
           s = s || (s = new MagicString(code));
           const [full, hash, postfix = ""] = match;
           const file = this.getFileName(hash);
-          const outputFilepath = normalizePath(resolvedConfig.base + file + postfix);
+          const prefix = settings.config.build.assetsPrefix ? appendForwardSlash(settings.config.build.assetsPrefix) : resolvedConfig.base;
+          const outputFilepath = prefix + normalizePath(file + postfix);
           s.overwrite(match.index, match.index + full.length, outputFilepath);
         }
         if (s) {

package/dist/content/runtime-assets.d.ts

@@ -1,8 +1,4 @@
+import type { PluginContext } from 'rollup';
 import { z } from 'zod';
-import { type Metadata } from '../assets/utils/metadata.js';
-export declare function createImage(options: {
-    assetsDir: string;
-    relAssetsDir: string;
-}): () => z.ZodEffects<z.ZodString, Metadata & {
-    __astro_asset: true;
-}, string>;
+import type { AstroSettings } from '../@types/astro.js';
+export declare function createImage(settings: AstroSettings, pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/utils/metadata.js").Metadata, string>;

package/dist/content/runtime-assets.js

@@ -1,16 +1,17 @@
-import { pathToFileURL } from "url";
 import { z } from "zod";
-import {
-  imageMetadata as internalGetImageMetadata
-} from "../assets/utils/metadata.js";
-function createImage(options) {
+import { emitESMImage } from "../assets/index.js";
+function createImage(settings, pluginContext, entryFilePath) {
   return () => {
-    if (options.assetsDir === "undefined") {
-      throw new Error("Enable `experimental.assets` in your Astro config to use image()");
-    }
-    return z.string({ description: "__image" }).transform(async (imagePath, ctx) => {
-      const imageMetadata = await getImageMetadata(pathToFileURL(imagePath));
-      if (!imageMetadata) {
+    return z.string().transform(async (imagePath, ctx) => {
+      var _a;
+      const resolvedFilePath = (_a = await pluginContext.resolve(imagePath, entryFilePath)) == null ? void 0 : _a.id;
+      const metadata = await emitESMImage(
+        resolvedFilePath,
+        pluginContext.meta.watchMode,
+        pluginContext.emitFile,
+        settings
+      );
+      if (!metadata) {
         ctx.addIssue({
           code: "custom",
           message: `Image ${imagePath} does not exist. Is the path correct?`,
@@ -18,18 +19,10 @@ function createImage(options) {
         });
         return z.NEVER;
       }
-      return imageMetadata;
+      return metadata;
     });
   };
 }
-async function getImageMetadata(imagePath) {
-  const meta = await internalGetImageMetadata(imagePath);
-  if (!meta) {
-    return void 0;
-  }
-  delete meta.orientation;
-  return { ...meta, __astro_asset: true };
-}
 export {
   createImage
 };

package/dist/content/template/virtual-mod.d.mts

@@ -1,3 +1,4 @@
 export function defineCollection(config: any): any;
+export function image(): never;
 export const getCollection: any;
 export const getEntryBySlug: any;

package/dist/content/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import matter from 'gray-matter';
 import fsMod from 'node:fs';
-import type { EmitFile, PluginContext } from 'rollup';
+import type { PluginContext } from 'rollup';
 import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
 import type { AstroConfig, AstroSettings } from '../@types/astro.js';
@@ -47,17 +47,13 @@ export type EntryInfo = {
 export declare const msg: {
     collectionConfigMissing: (collection: string) => string;
 };
-/**
- * Mutate (arf) the entryData to reroute assets to their final paths
- */
-export declare function patchAssets(frontmatterEntry: Record<string, any>, watchMode: boolean, fileEmitter: EmitFile, astroSettings: AstroSettings): Promise<void>;
 export declare function getEntrySlug({ id, collection, slug, unvalidatedSlug, }: EntryInfo & {
     unvalidatedSlug?: unknown;
 }): string;
 export declare function getEntryData(entry: EntryInfo & {
     unvalidatedData: Record<string, unknown>;
     _internal: EntryInternal;
-}, collectionConfig: CollectionConfig, resolver: (idToResolve: string) => ReturnType<PluginContext['resolve']>): Promise<{
+}, collectionConfig: CollectionConfig, pluginContext: PluginContext, settings: AstroSettings): Promise<{
     [x: string]: unknown;
 }>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];

package/dist/content/utils.js

@@ -5,10 +5,10 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { normalizePath } from "vite";
 import { z } from "zod";
-import { emitESMImage } from "../assets/utils/emitAsset.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { CONTENT_TYPES_FILE } from "./consts.js";
 import { errorMap } from "./error-map.js";
+import { createImage } from "./runtime-assets.js";
 const collectionConfigParser = z.object({
   schema: z.any().optional()
 });
@@ -25,22 +25,6 @@ const contentConfigParser = z.object({
 const msg = {
   collectionConfigMissing: (collection) => `${collection} does not have a config. We suggest adding one for type safety!`
 };
-async function patchAssets(frontmatterEntry, watchMode, fileEmitter, astroSettings) {
-  for (const key of Object.keys(frontmatterEntry)) {
-    if (typeof frontmatterEntry[key] === "object" && frontmatterEntry[key] !== null) {
-      if (frontmatterEntry[key]["__astro_asset"]) {
-        frontmatterEntry[key] = await emitESMImage(
-          frontmatterEntry[key].src,
-          watchMode,
-          fileEmitter,
-          astroSettings
-        );
-      } else {
-        await patchAssets(frontmatterEntry[key], watchMode, fileEmitter, astroSettings);
-      }
-    }
-  }
-}
 function getEntrySlug({
   id,
   collection,
@@ -56,50 +40,27 @@ function getEntrySlug({
     });
   }
 }
-async function getEntryData(entry, collectionConfig, resolver) {
+async function getEntryData(entry, collectionConfig, pluginContext, settings) {
   let { slug, ...data } = entry.unvalidatedData;
-  if (collectionConfig.schema) {
-    if (typeof collectionConfig.schema === "object" && !("safeParseAsync" in collectionConfig.schema)) {
-      throw new AstroError({
-        title: "Invalid content collection config",
-        message: `New: Content collection schemas must be Zod objects. Update your collection config to use \`schema: z.object({...})\` instead of \`schema: {...}\`.`,
-        hint: "See https://docs.astro.build/en/reference/api-reference/#definecollection for an example.",
-        code: 99999
-      });
+  let schema = collectionConfig.schema;
+  if (typeof schema === "function") {
+    if (!settings.config.experimental.assets) {
+      throw new Error(
+        "The function shape for schema can only be used when `experimental.assets` is enabled."
+      );
     }
-    if (typeof collectionConfig.schema === "object" && "shape" in collectionConfig.schema && collectionConfig.schema.shape.slug) {
+    schema = schema({
+      image: createImage(settings, pluginContext, entry._internal.filePath)
+    });
+  }
+  if (schema) {
+    if (typeof schema === "object" && "shape" in schema && schema.shape.slug) {
       throw new AstroError({
         ...AstroErrorData.ContentSchemaContainsSlugError,
         message: AstroErrorData.ContentSchemaContainsSlugError.message(entry.collection)
       });
     }
-    async function preprocessAssetPaths(object) {
-      if (typeof object !== "object" || object === null)
-        return;
-      for (let [schemaName, schema] of Object.entries(object)) {
-        if (schema._def.description === "__image") {
-          object[schemaName] = z.preprocess(
-            async (value) => {
-              var _a;
-              if (!value || typeof value !== "string")
-                return value;
-              return ((_a = await resolver(value)) == null ? void 0 : _a.id) ?? path.join(path.dirname(entry._internal.filePath), value);
-            },
-            schema,
-            { description: "__image" }
-          );
-        } else if ("shape" in schema) {
-          await preprocessAssetPaths(schema.shape);
-        } else if ("unwrap" in schema) {
-          const unwrapped = schema.unwrap().shape;
-          if (unwrapped) {
-            await preprocessAssetPaths(unwrapped);
-          }
-        }
-      }
-    }
-    await preprocessAssetPaths(collectionConfig.schema.shape);
-    const parsed = await collectionConfig.schema.safeParseAsync(entry.unvalidatedData, {
+    const parsed = await schema.safeParseAsync(entry.unvalidatedData, {
       errorMap
     });
     if (parsed.success) {
@@ -288,6 +249,5 @@ export {
   globalContentConfigObserver,
   loadContentConfig,
   msg,
-  parseFrontmatter,
-  patchAssets
+  parseFrontmatter
 };

package/dist/content/vite-plugin-content-assets.js

@@ -1,9 +1,8 @@
-import npath from "node:path";
 import { pathToFileURL } from "url";
 import { moduleIsTopLevelPage, walkParentInfos } from "../core/build/graph.js";
 import { getPageDataByViteID } from "../core/build/internal.js";
 import { createViteLoader } from "../core/module-loader/vite.js";
-import { prependForwardSlash } from "../core/path.js";
+import { joinPaths, prependForwardSlash } from "../core/path.js";
 import { getStylesForURL } from "../core/render/dev/css.js";
 import { getScriptsForURL } from "../core/render/dev/scripts.js";
 import {
@@ -59,7 +58,11 @@ function astroContentAssetPropagationPlugin({
           devModuleLoader,
           "development"
         );
-        const hoistedScripts = await getScriptsForURL(pathToFileURL(basePath), devModuleLoader);
+        const hoistedScripts = await getScriptsForURL(
+          pathToFileURL(basePath),
+          settings.config.root,
+          devModuleLoader
+        );
         return {
           code: code.replace(JSON.stringify(LINKS_PLACEHOLDER), JSON.stringify([...urls])).replace(JSON.stringify(STYLES_PLACEHOLDER), JSON.stringify([...stylesMap.values()])).replace(JSON.stringify(SCRIPTS_PLACEHOLDER), JSON.stringify([...hoistedScripts]))
         };
@@ -87,7 +90,13 @@ function astroConfigBuildPlugin(options, internals) {
       "build:post": ({ ssrOutputs, clientOutputs, mutate }) => {
         var _a, _b;
         const outputs = ssrOutputs.flatMap((o) => o.output);
-        const prependBase = (src) => prependForwardSlash(npath.posix.join(options.settings.config.base, src));
+        const prependBase = (src) => {
+          if (options.settings.config.build.assetsPrefix) {
+            return joinPaths(options.settings.config.build.assetsPrefix, src);
+          } else {
+            return prependForwardSlash(joinPaths(options.settings.config.base, src));
+          }
+        };
         for (const chunk of outputs) {
           if (chunk.type === "chunk" && (chunk.code.includes(LINKS_PLACEHOLDER) || chunk.code.includes(SCRIPTS_PLACEHOLDER))) {
             let entryCSS = /* @__PURE__ */ new Set();