astro 4.4.15 → 4.5.0

package/components/Code.astro

@@ -6,34 +6,35 @@ import type {
 	SpecialLanguage,
 	ThemeRegistration,
 	ThemeRegistrationRaw,
-} from 'shikiji';
-import { bundledLanguages } from 'shikiji/langs';
+} from 'shiki';
+import { bundledLanguages } from 'shiki/langs';
 import { getCachedHighlighter } from '../dist/core/shiki.js';
+import type { HTMLAttributes } from '../types';
 
-interface Props {
+interface Props extends Omit<HTMLAttributes<'pre'>, 'lang'> {
 	/** The code to highlight. Required. */
 	code: string;
 	/**
 	 * The language of your code.
-	 * Supports all languages listed here: https://github.com/shikijs/shiki/blob/main/docs/languages.md#all-languages
-	 * Instructions for loading a custom language: https://github.com/shikijs/shiki/blob/main/docs/languages.md#supporting-your-own-languages-with-shiki
+	 * Supports all languages listed here: https://shiki.style/languages
+	 * Instructions for loading a custom language: https://shiki.style/guide/load-lang
 	 *
 	 * @default "plaintext"
 	 */
 	lang?: BuiltinLanguage | SpecialLanguage | LanguageRegistration;
 	/**
 	 * The styling theme.
-	 * Supports all themes listed here: https://github.com/shikijs/shiki/blob/main/docs/themes.md#all-themes
-	 * Instructions for loading a custom theme: https://github.com/shikijs/shiki/blob/main/docs/themes.md#loading-theme
+	 * Supports all themes listed here: https://shiki.style/themes
+	 * Instructions for loading a custom theme: https://shiki.style/guide/load-theme
 	 *
 	 * @default "github-dark"
 	 */
 	theme?: ThemePresets | ThemeRegistration | ThemeRegistrationRaw;
 	/**
 	 * Multiple themes to style with -- alternative to "theme" option.
-	 * Supports all themes found above; see https://github.com/antfu/shikiji#lightdark-dual-themes for more information.
+	 * Supports all themes found above; see https://shiki.style/guide/dual-themes for more information.
 	 */
-	experimentalThemes?: Record<string, ThemePresets | ThemeRegistration | ThemeRegistrationRaw>;
+	themes?: Record<string, ThemePresets | ThemeRegistration | ThemeRegistrationRaw>;
 	/**
 	 * Enable word wrapping.
 	 *  - true: enabled.
@@ -55,12 +56,13 @@ const {
 	code,
 	lang = 'plaintext',
 	theme = 'github-dark',
-	experimentalThemes = {},
+	themes = {},
 	wrap = false,
 	inline = false,
+	...rest
 } = Astro.props;
 
-// shiki -> shikiji compat
+// shiki 1.0 compat
 if (typeof lang === 'object') {
 	// `id` renamed to `name` (always override)
 	if ((lang as any).id) {
@@ -81,12 +83,13 @@ const highlighter = await getCachedHighlighter({
 			: lang,
 	],
 	theme,
-	experimentalThemes,
+	themes,
 	wrap,
 });
 
 const html = highlighter.highlight(code, typeof lang === 'string' ? lang : lang.name, {
 	inline,
+	attributes: rest,
 });
 ---
 

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

@@ -7,7 +7,7 @@ import type * as babel from '@babel/core';
 import type * as rollup from 'rollup';
 import type * as vite from 'vite';
 import type { RemotePattern } from '../assets/utils/remotePattern.js';
-import type { SerializedSSRManifest } from '../core/app/types.js';
+import type { AssetsPrefix, SerializedSSRManifest } from '../core/app/types.js';
 import type { PageBuildData } from '../core/build/types.js';
 import type { AstroConfigType } from '../core/config/index.js';
 import type { AstroTimer } from '../core/config/timer.js';
@@ -27,7 +27,7 @@ export type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, Rehype
 export type { ExternalImageService, ImageService, LocalImageService, } from '../assets/services/service.js';
 export type { GetImageResult, ImageInputFormat, ImageMetadata, ImageOutputFormat, ImageQuality, ImageQualityPreset, ImageTransform, UnresolvedImageTransform, } from '../assets/types.js';
 export type { RemotePattern } from '../assets/utils/remotePattern.js';
-export type { SSRManifest } from '../core/app/types.js';
+export type { SSRManifest, AssetsPrefix } from '../core/app/types.js';
 export type { AstroCookieGetOptions, AstroCookieSetOptions, AstroCookies, } from '../core/cookies/index.js';
 export interface AstroBuiltinProps {
     'client:load'?: boolean;
@@ -779,17 +779,17 @@ export interface AstroUserConfig {
         /**
          * @docs
          * @name build.assetsPrefix
-         * @type {string}
+         * @type {string | Record<string, 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.
+         * This requires uploading the assets in your local `./dist/_astro` folder to a corresponding `/_astro/` folder on the remote domain.
          * To rename the `_astro` path, specify a new directory in `build.assets`.
          *
+         * To fetch all assets uploaded to the same domain (e.g. `https://cdn.example.com/_astro/...`), set `assetsPrefix` to the root domain as a string (regardless of your `base` configuration):
+         *
          * ```js
          * {
          *   build: {
@@ -797,8 +797,27 @@ export interface AstroUserConfig {
          *   }
          * }
          * ```
+         *
+         * **Added in:** `astro@4.5.0`
+         *
+         * You can also pass an object to `assetsPrefix` to specify a different domain for each file type.
+         * In this case, a `fallback` property is required and will be used by default for any other files.
+         *
+         * ```js
+         * {
+         *   build: {
+         *     assetsPrefix: {
+         *       'js': 'https://js.cdn.example.com',
+         *       'mjs': 'https://js.cdn.example.com',
+         *       'css': 'https://css.cdn.example.com',
+         *       'fallback': 'https://cdn.example.com'
+         *     }
+         *   }
+         * }
+         * ```
+         *
          */
-        assetsPrefix?: string;
+        assetsPrefix?: AssetsPrefix;
         /**
          * @docs
          * @name build.serverEntry
@@ -1177,7 +1196,7 @@ export interface AstroUserConfig {
          * @default `shiki`
          * @description
          * Which syntax highlighter to use, if any.
-         * - `shiki` - use the [Shiki](https://github.com/shikijs/shiki) highlighter
+         * - `shiki` - use the [Shiki](https://shiki.style) highlighter
          * - `prism` - use the [Prism](https://prismjs.com/) highlighter
          * - `false` - do not apply syntax highlighting.
          *
@@ -1478,25 +1497,30 @@ export interface AstroUserConfig {
     experimental?: {
         /**
          * @docs
-         * @name experimental.optimizeHoistedScript
+         * @name experimental.directRenderScript
          * @type {boolean}
          * @default `false`
-         * @version 2.10.4
+         * @version 4.5.0
          * @description
-         * Prevents unused components' scripts from being included in a page unexpectedly.
-         * The optimization is best-effort and may inversely miss including the used scripts. Make sure to double-check your built pages
-         * before publishing.
-         * Enable hoisted script analysis optimization by adding the experimental flag:
+         * Enables a more reliable strategy to prevent scripts from being executed in pages where they are not used.
+         *
+         * Scripts will directly render as declared in Astro files (including existing features like TypeScript, importing `node_modules`,
+         * and deduplicating scripts). You can also now conditionally render scripts in your Astro file.
+
+         * However, this means scripts are no longer hoisted to the `<head>` and multiple scripts on a page are no longer bundled together.
+         * If you enable this option, you should check that all your `<script>` tags behave as expected.
+         *
+         * This option will be enabled by default in Astro 5.0.
          *
          * ```js
          * {
-         * 	experimental: {
-         *		optimizeHoistedScript: true,
-         * 	},
+         *   experimental: {
+         *     directRenderScript: true,
+         *   },
          * }
          * ```
          */
-        optimizeHoistedScript?: boolean;
+        directRenderScript?: boolean;
         /**
          * @docs
          * @name experimental.contentCollectionCache
@@ -1515,6 +1539,53 @@ export interface AstroUserConfig {
          * ```
          */
         contentCollectionCache?: boolean;
+        /**
+         * @docs
+         * @name experimental.contentCollectionJsonSchema
+         * @type {boolean}
+         * @default `false`
+         * @version 4.5.0
+         * @description
+         * This feature will auto-generate a JSON schema for content collections of `type: 'data'` which can be used as the `$schema` value for TypeScript-style autocompletion/hints in tools like VSCode.
+         *
+         * To enable this feature, add the experimental flag:
+         *
+         * ```diff
+         * import { defineConfig } from 'astro/config';
+
+         * export default defineConfig({
+         * 	experimental: {
+         * +		contentCollectionJsonSchema: true
+         * 	}
+         * });
+         * ```
+         *
+         * This experimental implementation requires you to manually reference the schema in each data entry file of the collection:
+         *
+         * ```diff
+         * // src/content/test/entry.json
+         * {
+         * +  "$schema": "../../../.astro/collections/test.schema.json",
+         * 	"test": "test"
+         * }
+         * ```
+         *
+         * Alternatively, you can set this in your [VSCode `json.schemas` settings](https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings):
+         *
+         * ```diff
+         * "json.schemas": [
+         * 	{
+         * 		"fileMatch": [
+         * 			"/src/content/test/**"
+         * 		],
+         * 		"url": "../../../.astro/collections/test.schema.json"
+         * 	}
+         * ]
+         * ```
+         *
+         * Note that this initial implementation uses a library with [known issues for advanced Zod schemas](https://github.com/StefanTerdell/zod-to-json-schema#known-issues), so you may wish to consult these limitations before enabling the experimental flag.
+         */
+        contentCollectionJsonSchema?: boolean;
         /**
          * @docs
          * @name experimental.clientPrerender
@@ -2411,6 +2482,7 @@ export interface SSRResult {
     scripts: Set<SSRElement>;
     links: Set<SSRElement>;
     componentMetadata: Map<string, SSRComponentMetadata>;
+    inlinedScripts: Map<string, string>;
     createAstro(Astro: AstroGlobalPartial, props: Record<string, any>, slots: Record<string, any> | null): AstroGlobal;
     resolve: (s: string) => Promise<string>;
     response: AstroGlobal['response'];
@@ -2440,6 +2512,11 @@ export interface SSRMetadata {
      * script in the page HTML before the first Solid component.
      */
     rendererSpecificHydrationScripts: Set<string>;
+    /**
+     * Used by `renderScript` to track script ids that have been rendered,
+     * so we only render each once.
+     */
+    renderedScripts: Set<string>;
     hasDirectives: Set<string>;
     hasRenderedHead: boolean;
     headInTree: boolean;

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

@@ -0,0 +1,2 @@
+import type { AssetsPrefix } from '../../core/app/types.js';
+export declare function getAssetsPrefix(fileExtension: string, assetsPrefix?: AssetsPrefix): string;

package/dist/assets/utils/getAssetsPrefix.js

@@ -0,0 +1,14 @@
+function getAssetsPrefix(fileExtension, assetsPrefix) {
+  if (!assetsPrefix)
+    return "";
+  if (typeof assetsPrefix === "string")
+    return assetsPrefix;
+  const dotLessFileExtension = fileExtension.slice(1);
+  if (assetsPrefix[dotLessFileExtension]) {
+    return assetsPrefix[dotLessFileExtension];
+  }
+  return assetsPrefix.fallback;
+}
+export {
+  getAssetsPrefix
+};

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

@@ -1,3 +1,4 @@
+import { extname } from "node:path";
 import MagicString from "magic-string";
 import { normalizePath } from "vite";
 import { extendManualChunks } from "../core/build/plugins/util.js";
@@ -11,6 +12,7 @@ import {
 import { isServerLikeOutput } from "../prerender/utils.js";
 import { VALID_INPUT_FORMATS, VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
 import { emitESMImage } from "./utils/emitAsset.js";
+import { getAssetsPrefix } from "./utils/getAssetsPrefix.js";
 import { isESMImportedImage } from "./utils/imageKind.js";
 import { getProxyCode } from "./utils/proxy.js";
 import { hashTransform, propsToFilename } from "./utils/transformToPath.js";
@@ -73,7 +75,10 @@ function assets({
           if (!globalThis.astroAsset.staticImages) {
             globalThis.astroAsset.staticImages = /* @__PURE__ */ new Map();
           }
-          const finalOriginalImagePath = (isESMImportedImage(options.src) ? options.src.src : options.src).replace(settings.config.build.assetsPrefix || "", "");
+          const ESMImportedImageSrc = isESMImportedImage(options.src) ? options.src.src : options.src;
+          const fileExtension = extname(ESMImportedImageSrc);
+          const pf = getAssetsPrefix(fileExtension, settings.config.build.assetsPrefix);
+          const finalOriginalImagePath = ESMImportedImageSrc.replace(pf, "");
           const hash = hashTransform(
             options,
             settings.config.image.service.entrypoint,
@@ -101,7 +106,7 @@ function assets({
             });
           }
           if (settings.config.build.assetsPrefix) {
-            return encodeURI(joinPaths(settings.config.build.assetsPrefix, finalFilePath));
+            return encodeURI(joinPaths(pf, finalFilePath));
           } else {
             return encodeURI(prependForwardSlash(joinPaths(settings.config.base, finalFilePath)));
           }
@@ -116,7 +121,9 @@ function assets({
           s = s || (s = new MagicString(code));
           const [full, hash, postfix = ""] = match;
           const file = this.getFileName(hash);
-          const prefix = settings.config.build.assetsPrefix ? appendForwardSlash(settings.config.build.assetsPrefix) : resolvedConfig.base;
+          const fileExtension = extname(file);
+          const pf = getAssetsPrefix(fileExtension, settings.config.build.assetsPrefix);
+          const prefix = pf ? appendForwardSlash(pf) : resolvedConfig.base;
           const outputFilepath = prefix + normalizePath(file + postfix);
           s.overwrite(match.index, match.index + full.length, outputFilepath);
         }

package/dist/content/types-generator.js

@@ -3,6 +3,8 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import glob from "fast-glob";
 import { bold, cyan } from "kleur/colors";
 import { normalizePath } from "vite";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
 import { isRelativePath } from "../core/path.js";
@@ -72,7 +74,10 @@ async function createContentTypesGenerator({
         return { shouldGenerateTypes: false };
       switch (event.name) {
         case "addDir":
-          collectionEntryMap[JSON.stringify(collection2)] = { type: "unknown", entries: {} };
+          collectionEntryMap[JSON.stringify(collection2)] = {
+            type: "unknown",
+            entries: {}
+          };
           logger.debug("content", `${cyan(collection2)} collection added`);
           break;
         case "unlinkDir":
@@ -150,7 +155,11 @@ async function createContentTypesGenerator({
     const contentEntryType = contentEntryConfigByExt.get(path.extname(event.entry.pathname));
     if (!contentEntryType)
       return { shouldGenerateTypes: false };
-    const { id, slug: generatedSlug } = getContentEntryIdAndSlug({ entry, contentDir, collection });
+    const { id, slug: generatedSlug } = getContentEntryIdAndSlug({
+      entry,
+      contentDir,
+      collection
+    });
     const collectionKey = JSON.stringify(collection);
     if (!(collectionKey in collectionEntryMap)) {
       collectionEntryMap[collectionKey] = { type: "content", entries: {} };
@@ -181,7 +190,10 @@ async function createContentTypesGenerator({
         if (!(entryKey in collectionEntryMap[collectionKey].entries)) {
           collectionEntryMap[collectionKey] = {
             type: "content",
-            entries: { ...collectionInfo.entries, [entryKey]: { slug: addedSlug } }
+            entries: {
+              ...collectionInfo.entries,
+              [entryKey]: { slug: addedSlug }
+            }
           };
         }
         return { shouldGenerateTypes: true };
@@ -244,7 +256,9 @@ async function createContentTypesGenerator({
         typeTemplateContent,
         contentConfig: observable.status === "loaded" ? observable.config : void 0,
         contentEntryTypes: settings.contentEntryTypes,
-        viteServer
+        viteServer,
+        logger,
+        settings
       });
       invalidateVirtualMod(viteServer);
     }
@@ -269,12 +283,21 @@ async function writeContentFiles({
   typeTemplateContent,
   contentEntryTypes,
   contentConfig,
-  viteServer
+  viteServer,
+  logger,
+  settings
 }) {
   let contentTypesStr = "";
   let dataTypesStr = "";
+  const collectionSchemasDir = new URL("./collections/", contentPaths.cacheDir);
+  if (settings.config.experimental.contentCollectionJsonSchema && !fs.existsSync(collectionSchemasDir)) {
+    fs.mkdirSync(collectionSchemasDir, { recursive: true });
+  }
   for (const [collection, config] of Object.entries(contentConfig?.collections ?? {})) {
-    collectionEntryMap[JSON.stringify(collection)] ??= { type: config.type, entries: {} };
+    collectionEntryMap[JSON.stringify(collection)] ??= {
+      type: config.type,
+      entries: {}
+    };
   }
   for (const collectionKey of Object.keys(collectionEntryMap).sort()) {
     const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
@@ -292,7 +315,6 @@ async function writeContentFiles({
           hint: collection.type === "data" ? "Try adding `type: 'data'` to your collection config." : void 0,
           location: {
             file: ""
-            /** required for error overlay `hot` messages */
           }
         })
       });
@@ -337,6 +359,33 @@ async function writeContentFiles({
   data: ${dataType}
 };
 `;
+          if (settings.config.experimental.contentCollectionJsonSchema && collectionConfig?.schema) {
+            let zodSchemaForJson = collectionConfig.schema;
+            if (zodSchemaForJson instanceof z.ZodObject) {
+              zodSchemaForJson = zodSchemaForJson.extend({
+                $schema: z.string().optional()
+              });
+            }
+            try {
+              await fs.promises.writeFile(
+                new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
+                JSON.stringify(
+                  zodToJsonSchema(zodSchemaForJson, {
+                    name: collectionKey.replace(/"/g, ""),
+                    markdownDescription: true,
+                    errorMessages: true
+                  }),
+                  null,
+                  2
+                )
+              );
+            } catch (err) {
+              logger.warn(
+                "content",
+                `An error was encountered while creating the JSON schema. Proceeding without it. Error: ${err}`
+              );
+            }
+          }
         }
         dataTypesStr += `};
 `;

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

@@ -1,5 +1,6 @@
 import { extname } from "node:path";
 import { pathToFileURL } from "node:url";
+import { getAssetsPrefix } from "../assets/utils/getAssetsPrefix.js";
 import { moduleIsTopLevelPage, walkParentInfos } from "../core/build/graph.js";
 import { getPageDataByViteID } from "../core/build/internal.js";
 import { createViteLoader } from "../core/module-loader/vite.js";
@@ -54,7 +55,11 @@ function astroContentAssetPropagationPlugin({
             urls,
             crawledFiles: styleCrawledFiles
           } = await getStylesForURL(pathToFileURL(basePath), devModuleLoader);
-          const { scripts: hoistedScripts, crawledFiles: scriptCrawledFiles } = await getScriptsForURL(pathToFileURL(basePath), settings.config.root, devModuleLoader);
+          const { scripts: hoistedScripts, crawledFiles: scriptCrawledFiles } = settings.config.experimental.directRenderScript ? { scripts: /* @__PURE__ */ new Set(), crawledFiles: /* @__PURE__ */ new Set() } : await getScriptsForURL(
+            pathToFileURL(basePath),
+            settings.config.root,
+            devModuleLoader
+          );
           for (const file of styleCrawledFiles) {
             if (!file.includes("node_modules")) {
               this.addWatchFile(file);
@@ -108,8 +113,11 @@ function astroConfigBuildPlugin(options, internals) {
       "build:post": ({ ssrOutputs, clientOutputs, mutate }) => {
         const outputs = ssrOutputs.flatMap((o) => o.output);
         const prependBase = (src) => {
-          if (options.settings.config.build.assetsPrefix) {
-            return joinPaths(options.settings.config.build.assetsPrefix, src);
+          const { assetsPrefix } = options.settings.config.build;
+          if (assetsPrefix) {
+            const fileExtension = extname(src);
+            const pf = getAssetsPrefix(fileExtension, assetsPrefix);
+            return joinPaths(pf, src);
           } else {
             return prependForwardSlash(joinPaths(options.settings.config.base, src));
           }

package/dist/core/app/common.js

@@ -11,6 +11,7 @@ function deserializeManifest(serializedManifest) {
   }
   const assets = new Set(serializedManifest.assets);
   const componentMetadata = new Map(serializedManifest.componentMetadata);
+  const inlinedScripts = new Map(serializedManifest.inlinedScripts);
   const clientDirectives = new Map(serializedManifest.clientDirectives);
   return {
     // in case user middleware exists, this no-op middleware will be reassigned (see plugin-ssr.ts)
@@ -20,6 +21,7 @@ function deserializeManifest(serializedManifest) {
     ...serializedManifest,
     assets,
     componentMetadata,
+    inlinedScripts,
     clientDirectives,
     routes
   };

package/dist/core/app/index.js

@@ -1,5 +1,6 @@
 import { normalizeTheLocale } from "../../i18n/index.js";
 import {
+  DEFAULT_404_COMPONENT,
   REROUTABLE_STATUS_CODES,
   REROUTE_DIRECTIVE_HEADER,
   clientAddressSymbol,
@@ -20,6 +21,7 @@ import {
 import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
 import { RenderContext } from "../render-context.js";
 import { createAssetLink } from "../render/ssr-element.js";
+import { ensure404Route } from "../routing/astro-designed-error-pages.js";
 import { matchRoute } from "../routing/match.js";
 import { AppPipeline } from "./pipeline.js";
 import { deserializeManifest } from "./common.js";
@@ -36,9 +38,9 @@ class App {
   #renderOptionsDeprecationWarningShown = false;
   constructor(manifest, streaming = true) {
     this.#manifest = manifest;
-    this.#manifestData = {
+    this.#manifestData = ensure404Route({
       routes: manifest.routes.map((route) => route.routeData)
-    };
+    });
     this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#manifest.base);
     this.#pipeline = this.#createPipeline(streaming);
     this.#adapterLogger = new AstroIntegrationLogger(
@@ -348,6 +350,12 @@ class App {
     return 200;
   }
   async #getModuleForRoute(route) {
+    if (route.component === DEFAULT_404_COMPONENT) {
+      return {
+        page: async () => ({ default: () => new Response(null, { status: 404 }) }),
+        renderers: []
+      };
+    }
     if (route.type === "redirect") {
       return RedirectSinglePageBuiltModule;
     } else {

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

@@ -26,6 +26,9 @@ export type SerializedRouteInfo = Omit<RouteInfo, 'routeData'> & {
     routeData: SerializedRouteData;
 };
 export type ImportComponentInstance = () => Promise<SinglePageBuiltModule>;
+export type AssetsPrefix = string | ({
+    fallback: string;
+} & Record<string, string>) | undefined;
 export type SSRManifest = {
     adapterName: string;
     routes: RouteInfo[];
@@ -34,13 +37,14 @@ export type SSRManifest = {
     trailingSlash: 'always' | 'never' | 'ignore';
     buildFormat: 'file' | 'directory' | 'preserve';
     compressHTML: boolean;
-    assetsPrefix?: string;
+    assetsPrefix?: AssetsPrefix;
     renderers: SSRLoadedRenderer[];
     /**
      * Map of directive name (e.g. `load`) to the directive script code
      */
     clientDirectives: Map<string, string>;
     entryModules: Record<string, string>;
+    inlinedScripts: Map<string, string>;
     assets: Set<string>;
     componentMetadata: SSRResult['componentMetadata'];
     pageModule?: SinglePageBuiltModule;
@@ -55,9 +59,10 @@ export type SSRManifestI18n = {
     defaultLocale: string;
     domainLookupTable: Record<string, string>;
 };
-export type SerializedSSRManifest = Omit<SSRManifest, 'middleware' | 'routes' | 'assets' | 'componentMetadata' | 'clientDirectives'> & {
+export type SerializedSSRManifest = Omit<SSRManifest, 'middleware' | 'routes' | 'assets' | 'componentMetadata' | 'inlinedScripts' | 'clientDirectives'> & {
     routes: SerializedRouteInfo[];
     assets: string[];
     componentMetadata: [string, SSRComponentMetadata][];
+    inlinedScripts: [string, string][];
     clientDirectives: [string, string][];
 };

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

@@ -26,6 +26,7 @@ export declare abstract class Pipeline {
      */
     readonly adapterName: string;
     readonly clientDirectives: Map<string, string>;
+    readonly inlinedScripts: Map<string, string>;
     readonly compressHTML: boolean;
     readonly i18n: import("./app/types.js").SSRManifestI18n | undefined;
     readonly middleware: MiddlewareHandler;
@@ -47,7 +48,7 @@ export declare abstract class Pipeline {
     /**
      * Used to provide better error messages for `Astro.clientAddress`
      */
-    adapterName?: string, clientDirectives?: Map<string, string>, compressHTML?: boolean, i18n?: import("./app/types.js").SSRManifestI18n | undefined, middleware?: MiddlewareHandler, routeCache?: RouteCache, 
+    adapterName?: string, clientDirectives?: Map<string, string>, inlinedScripts?: Map<string, string>, compressHTML?: boolean, i18n?: import("./app/types.js").SSRManifestI18n | undefined, middleware?: MiddlewareHandler, routeCache?: RouteCache, 
     /**
      * Used for `Astro.site`.
      */

package/dist/core/base-pipeline.js

@@ -1,7 +1,7 @@
 import { createI18nMiddleware } from "../i18n/middleware.js";
 import { RouteCache } from "./render/route-cache.js";
 class Pipeline {
-  constructor(logger, manifest, mode, renderers, resolve, serverLike, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, mode), site = manifest.site ? new URL(manifest.site) : void 0) {
+  constructor(logger, manifest, mode, renderers, resolve, serverLike, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, mode), site = manifest.site ? new URL(manifest.site) : void 0) {
     this.logger = logger;
     this.manifest = manifest;
     this.mode = mode;
@@ -11,6 +11,7 @@ class Pipeline {
     this.streaming = streaming;
     this.adapterName = adapterName;
     this.clientDirectives = clientDirectives;
+    this.inlinedScripts = inlinedScripts;
     this.compressHTML = compressHTML;
     this.i18n = i18n;
     this.middleware = middleware;

package/dist/core/build/generate.js

@@ -421,6 +421,7 @@ function createBuildManifest(settings, internals, renderers, middleware) {
     trailingSlash: settings.config.trailingSlash,
     assets: /* @__PURE__ */ new Set(),
     entryModules: Object.fromEntries(internals.entrySpecifierToBundleMap.entries()),
+    inlinedScripts: internals.inlinedScripts,
     routes: [],
     adapterName: "",
     clientDirectives: settings.clientDirectives,

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

@@ -13,6 +13,12 @@ export interface BuildInternals {
     cssModuleToChunkIdMap: Map<string, string>;
     hoistedScriptIdToHoistedMap: Map<string, Set<string>>;
     hoistedScriptIdToPagesMap: Map<string, Set<string>>;
+    /**
+     * Used by the `directRenderScript` option. If script is inlined, its id and
+     * inlined code is mapped here. The resolved id is an URL like "/_astro/something.js"
+     * but will no longer exist as the content is now inlined in this map.
+     */
+    inlinedScripts: Map<string, string>;
     entrySpecifierToBundleMap: Map<string, string>;
     /**
      * A map to get a specific page's bundled output file.

package/dist/core/build/internal.js

@@ -14,6 +14,7 @@ function createBuildInternals() {
     cssModuleToChunkIdMap: /* @__PURE__ */ new Map(),
     hoistedScriptIdToHoistedMap,
     hoistedScriptIdToPagesMap,
+    inlinedScripts: /* @__PURE__ */ new Map(),
     entrySpecifierToBundleMap: /* @__PURE__ */ new Map(),
     pageToBundleMap: /* @__PURE__ */ new Map(),
     pagesByComponent: /* @__PURE__ */ new Map(),