astro 7.1.5 → 7.2.0

package/dist/content/types-generator.js

@@ -373,6 +373,7 @@ async function writeContentFiles({
   data: ${dataType};
   rendered?: RenderedContent;
   filePath?: string;
+  digest?: string | number;
 }>;
 `;
     if (collectionConfig && (collectionConfig.schema || await getContentLayerSchema(collectionConfig, collectionKey))) {

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

@@ -1,5 +1,6 @@
 import { extname } from "node:path";
 import { getAssetsPrefix } from "../assets/utils/getAssetsPrefix.js";
+import { createContentDataIncrementalMetadata } from "../core/build/incremental-metadata.js";
 import { fileExtension } from "../core/path.js";
 import { fileURLToPath } from "node:url";
 import { isRunnableDevEnvironment } from "vite";
@@ -107,7 +108,11 @@ function astroContentAssetPropagationPlugin({
 					const defaultMod = { __astroPropagation: true, getMod, collectedLinks, collectedStyles, collectedScripts: [] };
 					export default defaultMod;
 				`;
-          return { code, map: { mappings: "" } };
+          return {
+            code,
+            map: { mappings: "" },
+            meta: createContentDataIncrementalMetadata()
+          };
         }
       }
     }

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

@@ -2,6 +2,8 @@ import { extname } from "node:path";
 import { pathToFileURL } from "node:url";
 import * as devalue from "devalue";
 import { getProxyCode } from "../assets/utils/proxy.js";
+import { createContentDataIncrementalMetadata } from "../core/build/incremental-metadata.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
 import { CONTENT_FLAG, DATA_FLAG } from "./consts.js";
@@ -22,7 +24,6 @@ import {
   reloadContentConfigObserver,
   reverseSymlink
 } from "./utils.js";
-import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 function getContentRendererByViteId(viteId, settings) {
   let ext = viteId.split(".").pop();
   if (!ext) return void 0;
@@ -91,7 +92,11 @@ export const _internal = {
 	rawData: ${JSON.stringify(_internal.rawData)},
 };
 `;
-            return code;
+            return {
+              code,
+              map: { mappings: "" },
+              meta: createContentDataIncrementalMetadata()
+            };
           } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
             const fileId = reverseSymlink({ entry: viteId.split("?")[0], contentDir, symlinks });
             const { id, slug, collection, body, data, _internal } = await getContentEntryModule({
@@ -114,7 +119,11 @@ export const _internal = {
 							filePath: ${JSON.stringify(_internal.filePath)},
 							rawData: ${JSON.stringify(_internal.rawData)},
 						};`;
-            return { code, map: { mappings: "" } };
+            return {
+              code,
+              map: { mappings: "" },
+              meta: createContentDataIncrementalMetadata()
+            };
           }
         }
       },

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -1,7 +1,7 @@
 import nodeFs from "node:fs";
 import { fileURLToPath } from "node:url";
-import { dataToEsm } from "@rollup/pluginutils";
 import { isRunnableDevEnvironment, normalizePath } from "vite";
+import { createContentDataIncrementalMetadata } from "../core/build/incremental-metadata.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/viteUtils.js";
@@ -13,18 +13,21 @@ import {
   ASSET_IMPORTS_VIRTUAL_ID,
   CONTENT_MODULE_FLAG,
   CONTENT_RENDER_FLAG,
+  DATA_STORE_CHUNK_FILE_NAME_PATTERN,
+  DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX,
   DATA_STORE_MANIFEST_FILE,
   DATA_STORE_VIRTUAL_ID,
   MODULES_IMPORTS_FILE,
   MODULES_MJS_ID,
   MODULES_MJS_VIRTUAL_ID,
+  RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX,
+  RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX,
   RESOLVED_DATA_STORE_VIRTUAL_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 } from "./consts.js";
-import { getDataStoreDir, getDataStoreFile } from "./paths.js";
+import { getDataStoreChunkSize, getDataStoreDir, getDataStoreFile } from "./paths.js";
 import { getContentPaths, isDeferredModule } from "./utils.js";
-const LARGE_DATA_STORE_THRESHOLD = 5 * 1024 * 1024;
 function invalidateAssetImports(viteServer, filePath) {
   const timestamp = Date.now();
   for (const environment of Object.values(viteServer.environments)) {
@@ -81,11 +84,11 @@ function astroContentVirtualModPlugin({
     enforce: "pre",
     config(_, env) {
       isDev = env.command === "serve";
-      if (settings.config.experimental.collectionStorage === "chunked") {
-        dataStoreDir = getDataStoreDir(settings, env.command === "serve");
+      dataStoreDir = getDataStoreDir(settings, isDev);
+      if (getDataStoreChunkSize(settings) !== void 0) {
         dataStoreFile = new URL(DATA_STORE_MANIFEST_FILE, dataStoreDir);
       } else {
-        dataStoreFile = getDataStoreFile(settings, env.command === "serve");
+        dataStoreFile = getDataStoreFile(settings, isDev);
       }
       const contentPaths = getContentPaths(
         settings.config,
@@ -108,7 +111,7 @@ function astroContentVirtualModPlugin({
     resolveId: {
       filter: {
         id: new RegExp(
-          `^(${VIRTUAL_MODULE_ID}|${DATA_STORE_VIRTUAL_ID}|${MODULES_MJS_ID}|${ASSET_IMPORTS_VIRTUAL_ID})$|(?:\\?|&)${CONTENT_MODULE_FLAG}(?:&|=|$)`
+          `^(${VIRTUAL_MODULE_ID}|${DATA_STORE_VIRTUAL_ID}|${MODULES_MJS_ID}|${ASSET_IMPORTS_VIRTUAL_ID})$|^${DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX}|(?:\\?|&)${CONTENT_MODULE_FLAG}(?:&|=|$)`
         )
       },
       async handler(id, importer) {
@@ -123,6 +126,13 @@ function astroContentVirtualModPlugin({
         if (id === DATA_STORE_VIRTUAL_ID) {
           return RESOLVED_DATA_STORE_VIRTUAL_ID;
         }
+        if (id.startsWith(DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX)) {
+          const fileName = id.slice(DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX.length);
+          if (!DATA_STORE_CHUNK_FILE_NAME_PATTERN.test(fileName)) {
+            this.error(`Invalid data-store chunk: ${fileName}`);
+          }
+          return `${RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX}${fileName}${RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX}`;
+        }
         if (isDeferredModule(id)) {
           const [, query] = id.split("?");
           const params = new URLSearchParams(query);
@@ -138,14 +148,20 @@ function astroContentVirtualModPlugin({
         if (id === MODULES_MJS_ID) {
           const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
           if (fs.existsSync(modules)) {
-            return fileURLToPath(modules);
+            return {
+              id: fileURLToPath(modules),
+              meta: createContentDataIncrementalMetadata()
+            };
           }
           return MODULES_MJS_VIRTUAL_ID;
         }
         if (id === ASSET_IMPORTS_VIRTUAL_ID) {
           const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
           if (fs.existsSync(assetImportsFile)) {
-            return fileURLToPath(assetImportsFile);
+            return {
+              id: fileURLToPath(assetImportsFile),
+              meta: createContentDataIncrementalMetadata()
+            };
           }
           return ASSET_IMPORTS_RESOLVED_STUB_ID;
         }
@@ -154,10 +170,31 @@ function astroContentVirtualModPlugin({
     load: {
       filter: {
         id: new RegExp(
-          `^(${RESOLVED_VIRTUAL_MODULE_ID}|${RESOLVED_DATA_STORE_VIRTUAL_ID}|${ASSET_IMPORTS_RESOLVED_STUB_ID}|${MODULES_MJS_VIRTUAL_ID})$`
+          `^(${RESOLVED_VIRTUAL_MODULE_ID}|${RESOLVED_DATA_STORE_VIRTUAL_ID}|${ASSET_IMPORTS_RESOLVED_STUB_ID}|${MODULES_MJS_VIRTUAL_ID})$|^${RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX}`
         )
       },
       async handler(id) {
+        if (id.startsWith(RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX)) {
+          const resolvedFileName = id.slice(RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX.length);
+          if (!resolvedFileName.endsWith(RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX)) {
+            this.error(`Invalid data-store chunk: ${resolvedFileName}`);
+          }
+          const fileName = resolvedFileName.slice(
+            0,
+            -RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX.length
+          );
+          if (!DATA_STORE_CHUNK_FILE_NAME_PATTERN.test(fileName)) {
+            this.error(`Invalid data-store chunk: ${fileName}`);
+          }
+          const contents = await fs.promises.readFile(
+            new URL(`./${fileName}`, dataStoreDir),
+            "utf-8"
+          );
+          return {
+            code: `export default ${JSON.stringify(contents)}`,
+            map: { mappings: "" }
+          };
+        }
         if (id === RESOLVED_VIRTUAL_MODULE_ID) {
           const isClient = isAstroClientEnvironment(this.environment);
           const code = await generateContentEntryFile({
@@ -176,53 +213,54 @@ function astroContentVirtualModPlugin({
         }
         if (id === RESOLVED_DATA_STORE_VIRTUAL_ID) {
           if (!fs.existsSync(dataStoreFile)) {
-            return { code: "export default new Map()" };
+            return {
+              code: "export default new Map()",
+              meta: createContentDataIncrementalMetadata()
+            };
           }
           const jsonData = await fs.promises.readFile(dataStoreFile, "utf-8");
-          if (settings.config.experimental.collectionStorage === "chunked") {
+          if (getDataStoreChunkSize(settings) !== void 0) {
             try {
               const manifest = JSON.parse(jsonData);
-              const rawImport = (fileName) => {
-                const path = rootRelativePath(
-                  settings.config.root,
-                  new URL(`./${fileName}`, dataStoreDir)
-                );
-                return `(await import(${JSON.stringify(`${path}?raw`)}))`;
-              };
+              const chunkImport = (fileName) => `(await import(${JSON.stringify(`${DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX}${fileName}`)}))`;
               const entries = Object.entries(manifest).map(
-                ([collection, parts]) => `${JSON.stringify(collection)}:[${parts.map(rawImport).join(",")}]`
+                ([collection, parts]) => `${JSON.stringify(collection)}:[${parts.map(chunkImport).join(",")}]`
               );
               const code = `export default{${entries.join(",")}}`;
-              return { code, map: { mappings: "" } };
+              return {
+                code,
+                map: { mappings: "" },
+                meta: createContentDataIncrementalMetadata()
+              };
             } catch (err) {
               const message = "Could not parse data store manifest JSON file";
               this.error({ message, id, cause: err });
             }
           }
           try {
-            const parsed = JSON.parse(jsonData);
-            const useRuntimeJsonParse = isDev && Buffer.byteLength(jsonData) > LARGE_DATA_STORE_THRESHOLD;
-            return {
-              code: useRuntimeJsonParse ? `export default JSON.parse(${JSON.stringify(jsonData)})` : dataToEsm(parsed, {
-                compact: true
-              }),
-              map: { mappings: "" }
-            };
+            JSON.parse(jsonData);
           } catch (err) {
             const message = "Could not parse JSON file";
             this.error({ message, id, cause: err });
           }
+          return {
+            code: `export default JSON.parse(${JSON.stringify(jsonData)})`,
+            map: { mappings: "" },
+            meta: createContentDataIncrementalMetadata()
+          };
         }
         if (id === ASSET_IMPORTS_RESOLVED_STUB_ID) {
           const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
           return {
-            code: fs.existsSync(assetImportsFile) ? fs.readFileSync(assetImportsFile, "utf-8") : "export default new Map()"
+            code: fs.existsSync(assetImportsFile) ? fs.readFileSync(assetImportsFile, "utf-8") : "export default new Map()",
+            meta: createContentDataIncrementalMetadata()
           };
         }
         if (id === MODULES_MJS_VIRTUAL_ID) {
           const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
           return {
-            code: fs.existsSync(modules) ? fs.readFileSync(modules, "utf-8") : "export default new Map()"
+            code: fs.existsSync(modules) ? fs.readFileSync(modules, "utf-8") : "export default new Map()",
+            meta: createContentDataIncrementalMetadata()
           };
         }
       }

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

@@ -5,3 +5,5 @@ export { fromRoutingStrategy, toRoutingStrategy } from '../common.js';
 export { createConsoleLogger } from '../../logger/impls/console.js';
 export { deserializeManifest, deserializeRouteData, deserializeRouteInfo, serializeRouteData, serializeRouteInfo, } from '../manifest.js';
 export { AppPipeline } from '../pipeline.js';
+export { beginContentEntryCollection, endContentEntryCollection, } from '../../build/incremental-content-collector.js';
+export { beginImageCollection, endImageCollection, recordStaticImage, } from '../../build/incremental-image-collector.js';

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

@@ -12,15 +12,29 @@ import {
   serializeRouteInfo
 } from "../manifest.js";
 import { AppPipeline } from "../pipeline.js";
+import {
+  beginContentEntryCollection,
+  endContentEntryCollection
+} from "../../build/incremental-content-collector.js";
+import {
+  beginImageCollection,
+  endImageCollection,
+  recordStaticImage
+} from "../../build/incremental-image-collector.js";
 export {
   App,
   AppPipeline,
   BaseApp,
+  beginContentEntryCollection,
+  beginImageCollection,
   createConsoleLogger,
   deserializeManifest,
   deserializeRouteData,
   deserializeRouteInfo,
+  endContentEntryCollection,
+  endImageCollection,
   fromRoutingStrategy,
+  recordStaticImage,
   serializeRouteData,
   serializeRouteInfo,
   toRoutingStrategy

package/dist/core/build/config-hash/index.d.ts

@@ -0,0 +1,8 @@
+import type { AstroConfig } from '../../../types/public/config.js';
+export { getConfigHashInput } from './input.js';
+/**
+ * Produce a sha256 over the output-affecting subset of the resolved config (see
+ * {@link getConfigHashInput}). A mismatch invalidates the whole incremental
+ * build cache.
+ */
+export declare function computeConfigHash(config: AstroConfig): Promise<string>;

package/dist/core/build/config-hash/index.js

@@ -0,0 +1,23 @@
+import { encodeHexLowerCase } from "@oslojs/encoding";
+import { getConfigHashInput } from "./input.js";
+import { getConfigHashInput as getConfigHashInput2 } from "./input.js";
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      return Object.keys(val).sort().reduce((acc, key) => {
+        acc[key] = val[key];
+        return acc;
+      }, {});
+    }
+    return val;
+  });
+}
+async function computeConfigHash(config) {
+  const input = stableStringify(getConfigHashInput(config));
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+  return encodeHexLowerCase(new Uint8Array(digest));
+}
+export {
+  computeConfigHash,
+  getConfigHashInput2 as getConfigHashInput
+};

package/dist/core/build/config-hash/input.d.ts

@@ -0,0 +1,199 @@
+import type { AstroConfig } from '../../../types/public/config.js';
+/**
+ * Projection of {@link AstroConfig} limited to values that can change the bytes
+ * or paths of a prerendered page. A change to any of these must invalidate the
+ * incremental build cache: the per-route dependency hash only sees module
+ * *source*, so it misses config baked into compiled output by the compiler
+ * (`compressHTML`, `site`, `scopedStyleStrategy`), inlined via Vite `define`
+ * (`base`, `build.assetsPrefix`), or serialized into virtual modules (`image`,
+ * `env.schema`, `i18n`).
+ *
+ * Only serializable values are included. Function-valued config (integrations,
+ * vite/remark/rehype plugins, image services) is omitted because it cannot be
+ * serialized. `outDir`/`publicDir` are omitted too, since they move where files
+ * are written without changing a page's bytes.
+ *
+ * The whole `vite` config cannot be hashed: it carries plugins and other
+ * function-valued, per-run state that churns between builds and would sink the
+ * cache hit rate. Instead a curated allowlist of serializable Vite options that
+ * change emitted bytes or asset paths is included (e.g. `build.assetsInlineLimit`
+ * flips an asset between an inlined data URI and a separate hashed file). This
+ * allowlist is best-effort, so an obscure output-affecting Vite option outside
+ * it will not invalidate the cache; `--force` is the escape hatch.
+ *
+ * The set of fields is asserted against the full config schema in
+ * `test/units/build/config-hash.test.ts`, which fails when a new top-level
+ * config key appears so it gets classified here or explicitly excluded.
+ */
+export declare function getConfigHashInput(config: AstroConfig): {
+    site: string | undefined;
+    base: string;
+    trailingSlash: "never" | "ignore" | "always";
+    output: "server" | "static";
+    compressHTML: boolean | "jsx";
+    scopedStyleStrategy: "where" | "class" | "attribute";
+    build: {
+        format: "file" | "directory" | "preserve";
+        assets: string;
+        assetsPrefix: string | ({
+            fallback: string;
+        } & Record<string, string>) | undefined;
+        inlineStylesheets: "never" | "always" | "auto";
+        redirects: boolean;
+    };
+    redirects: Record<string, string | {
+        status: 301 | 302 | 303 | 307 | 308 | 300 | 304;
+        destination: string;
+    }>;
+    i18n: {
+        defaultLocale: string;
+        locales: (string | {
+            path: string;
+            codes: [string, ...string[]];
+        })[];
+        routing: "manual" | {
+            prefixDefaultLocale: boolean;
+            redirectToDefaultLocale: boolean;
+            fallbackType: "redirect" | "rewrite";
+        };
+        domains?: Record<string, string> | undefined;
+        fallback?: Record<string, string> | undefined;
+    } | undefined;
+    image: {
+        endpoint: {
+            route: string;
+            entrypoint?: string | undefined;
+        };
+        service: {
+            entrypoint: string;
+            config: Record<string, any>;
+        };
+        dangerouslyProcessSVG: boolean;
+        domains: string[];
+        remotePatterns: {
+            protocol?: string | undefined;
+            hostname?: string | undefined;
+            port?: string | undefined;
+            pathname?: string | undefined;
+        }[];
+        responsiveStyles: boolean;
+        layout?: "fixed" | "constrained" | "full-width" | "none" | undefined;
+        objectFit?: string | undefined;
+        objectPosition?: string | undefined;
+        breakpoints?: number[] | undefined;
+    };
+    markdown: {
+        syntaxHighlight: false | "shiki" | "prism" | {
+            type: "shiki" | "prism";
+            excludeLangs?: string[] | undefined;
+        };
+        shikiConfig: {
+            langs: (import("shiki").LanguageRegistration & import("../../config/schemas/base.js").ComplexifyUnionObj)[];
+            langAlias: Record<string, string>;
+            theme: "andromeeda" | "aurora-x" | "ayu-dark" | "ayu-light" | "ayu-mirage" | "catppuccin-frappe" | "catppuccin-latte" | "catppuccin-macchiato" | "catppuccin-mocha" | "dark-plus" | "dracula" | "dracula-soft" | "everforest-dark" | "everforest-light" | "github-dark" | "github-dark-default" | "github-dark-dimmed" | "github-dark-high-contrast" | "github-light" | "github-light-default" | "github-light-high-contrast" | "gruvbox-dark-hard" | "gruvbox-dark-medium" | "gruvbox-dark-soft" | "gruvbox-light-hard" | "gruvbox-light-medium" | "gruvbox-light-soft" | "horizon" | "horizon-bright" | "houston" | "kanagawa-dragon" | "kanagawa-lotus" | "kanagawa-wave" | "laserwave" | "light-plus" | "material-theme" | "material-theme-darker" | "material-theme-lighter" | "material-theme-ocean" | "material-theme-palenight" | "min-dark" | "min-light" | "monokai" | "night-owl" | "night-owl-light" | "nord" | "one-dark-pro" | "one-light" | "plastic" | "poimandres" | "red" | "rose-pine" | "rose-pine-dawn" | "rose-pine-moon" | "slack-dark" | "slack-ochin" | "snazzy-light" | "solarized-dark" | "solarized-light" | "synthwave-84" | "tokyo-night" | "vesper" | "vitesse-black" | "vitesse-dark" | "vitesse-light" | (NonNullable<(import("shiki").BundledTheme | "css-variables") | import("shiki").ThemeRegistration | import("shiki").ThemeRegistrationRaw | undefined> & import("../../config/schemas/base.js").ComplexifyUnionObj);
+            themes: Record<string, "andromeeda" | "aurora-x" | "ayu-dark" | "ayu-light" | "ayu-mirage" | "catppuccin-frappe" | "catppuccin-latte" | "catppuccin-macchiato" | "catppuccin-mocha" | "dark-plus" | "dracula" | "dracula-soft" | "everforest-dark" | "everforest-light" | "github-dark" | "github-dark-default" | "github-dark-dimmed" | "github-dark-high-contrast" | "github-light" | "github-light-default" | "github-light-high-contrast" | "gruvbox-dark-hard" | "gruvbox-dark-medium" | "gruvbox-dark-soft" | "gruvbox-light-hard" | "gruvbox-light-medium" | "gruvbox-light-soft" | "horizon" | "horizon-bright" | "houston" | "kanagawa-dragon" | "kanagawa-lotus" | "kanagawa-wave" | "laserwave" | "light-plus" | "material-theme" | "material-theme-darker" | "material-theme-lighter" | "material-theme-ocean" | "material-theme-palenight" | "min-dark" | "min-light" | "monokai" | "night-owl" | "night-owl-light" | "nord" | "one-dark-pro" | "one-light" | "plastic" | "poimandres" | "red" | "rose-pine" | "rose-pine-dawn" | "rose-pine-moon" | "slack-dark" | "slack-ochin" | "snazzy-light" | "solarized-dark" | "solarized-light" | "synthwave-84" | "tokyo-night" | "vesper" | "vitesse-black" | "vitesse-dark" | "vitesse-light" | (NonNullable<(import("shiki").BundledTheme | "css-variables") | import("shiki").ThemeRegistration | import("shiki").ThemeRegistrationRaw | undefined> & import("../../config/schemas/base.js").ComplexifyUnionObj)>;
+            wrap: boolean | null;
+            transformers: (import("shiki").ShikiTransformer & import("../../config/schemas/base.js").ComplexifyUnionObj)[];
+            defaultColor?: string | false | undefined;
+        };
+        remarkPlugins: (string | [string, any] | (import("@astrojs/markdown-remark").RemarkPlugin & import("../../config/schemas/base.js").ComplexifyUnionObj) | [import("@astrojs/markdown-remark").RemarkPlugin & import("../../config/schemas/base.js").ComplexifyUnionObj, any])[];
+        rehypePlugins: (string | [string, any] | (import("@astrojs/markdown-remark").RehypePlugin & import("../../config/schemas/base.js").ComplexifyUnionObj) | [import("@astrojs/markdown-remark").RehypePlugin & import("../../config/schemas/base.js").ComplexifyUnionObj, any])[];
+        remarkRehype: import("../../config/schemas/base.js").RemarkRehype;
+        processor: {
+            name: string;
+            options: object;
+            createRenderer: (shared: import("@astrojs/markdown-remark").AstroMarkdownOptions) => Promise<import("@astrojs/markdown-remark").MarkdownRenderer>;
+            createMdxRenderer?: ((shared: import("@astrojs/markdown-remark").AstroMarkdownOptions, mdx: import("@astrojs/internal-helpers/markdown").MdxRendererOptions) => Promise<import("@astrojs/internal-helpers/markdown").MdxRenderer>) | undefined;
+        };
+        gfm?: boolean | undefined;
+        smartypants?: false | import("../../config/schemas/base.js").Smartypants | undefined;
+    };
+    env: {
+        schema: Record<string, ({
+            context: "client";
+            access: "public";
+        } | {
+            context: "server";
+            access: "public";
+        } | {
+            context: "server";
+            access: "secret";
+        }) & ({
+            type: "enum";
+            values: string[];
+            optional?: boolean | undefined;
+            default?: string | undefined;
+        } | {
+            type: "string";
+            optional?: boolean | undefined;
+            default?: string | undefined;
+            max?: number | undefined;
+            min?: number | undefined;
+            length?: number | undefined;
+            url?: boolean | undefined;
+            includes?: string | undefined;
+            startsWith?: string | undefined;
+            endsWith?: string | undefined;
+        } | {
+            type: "number";
+            optional?: boolean | undefined;
+            default?: number | undefined;
+            gt?: number | undefined;
+            min?: number | undefined;
+            lt?: number | undefined;
+            max?: number | undefined;
+            int?: boolean | undefined;
+        } | {
+            type: "boolean";
+            optional?: boolean | undefined;
+            default?: boolean | undefined;
+        })>;
+    };
+    security: {
+        csp: boolean | {
+            algorithm: "SHA-256" | "SHA-384" | "SHA-512";
+            directives?: (`base-uri${string}` | `child-src${string}` | `connect-src${string}` | `default-src${string}` | `fenced-frame-src${string}` | `font-src${string}` | `form-action${string}` | `frame-ancestors${string}` | `frame-src${string}` | `img-src${string}` | `manifest-src${string}` | `media-src${string}` | `object-src${string}` | `referrer${string}` | `report-to${string}` | `report-uri${string}` | `require-trusted-types-for${string}` | `sandbox${string}` | `trusted-types${string}` | `upgrade-insecure-requests${string}` | `worker-src${string}`)[] | undefined;
+            styleDirective?: {
+                resources?: (string | {
+                    resource: string;
+                    kind: "default" | "attribute" | "element";
+                })[] | undefined;
+                hashes?: (`sha256-${string}` | `sha384-${string}` | `sha512-${string}` | {
+                    hash: `sha256-${string}` | `sha384-${string}` | `sha512-${string}`;
+                    kind: "default" | "attribute" | "element";
+                })[] | undefined;
+            } | undefined;
+            scriptDirective?: {
+                resources?: (string | {
+                    resource: string;
+                    kind: "default" | "attribute" | "element";
+                })[] | undefined;
+                hashes?: (`sha256-${string}` | `sha384-${string}` | `sha512-${string}` | {
+                    hash: `sha256-${string}` | `sha384-${string}` | `sha512-${string}`;
+                    kind: "default" | "attribute" | "element";
+                })[] | undefined;
+                strictDynamic?: boolean | undefined;
+            } | undefined;
+        };
+    };
+    prefetch: boolean | {
+        prefetchAll?: boolean | undefined;
+        defaultStrategy?: "tap" | "hover" | "viewport" | "load" | undefined;
+    } | undefined;
+    vite: {
+        build: {
+            assetsInlineLimit: number | ((filePath: string, content: Buffer) => boolean | undefined) | undefined;
+            minify: boolean | "esbuild" | "oxc" | "terser" | undefined;
+            cssMinify: boolean | "esbuild" | "lightningcss" | undefined;
+            cssTarget: false | import("vite/types/internal/esbuildOptions.js").EsbuildTarget | undefined;
+            target: false | import("vite/types/internal/esbuildOptions.js").EsbuildTarget | undefined;
+        };
+        css: import("vite").CSSOptions | undefined;
+        json: import("vite").JsonOptions | undefined;
+        define: Record<string, any> | undefined;
+        oxc: false | import("vite").OxcOptions | undefined;
+    };
+    experimental: {
+        clientPrerender: boolean;
+    };
+};

package/dist/core/build/config-hash/input.js

@@ -0,0 +1,43 @@
+function getConfigHashInput(config) {
+  return {
+    site: config.site,
+    base: config.base,
+    trailingSlash: config.trailingSlash,
+    output: config.output,
+    compressHTML: config.compressHTML,
+    scopedStyleStrategy: config.scopedStyleStrategy,
+    build: {
+      format: config.build.format,
+      assets: config.build.assets,
+      assetsPrefix: config.build.assetsPrefix,
+      inlineStylesheets: config.build.inlineStylesheets,
+      redirects: config.build.redirects
+    },
+    redirects: config.redirects,
+    i18n: config.i18n,
+    image: config.image,
+    markdown: config.markdown,
+    env: { schema: config.env?.schema },
+    security: { csp: config.security?.csp },
+    prefetch: config.prefetch,
+    vite: {
+      build: {
+        assetsInlineLimit: config.vite.build?.assetsInlineLimit,
+        minify: config.vite.build?.minify,
+        cssMinify: config.vite.build?.cssMinify,
+        cssTarget: config.vite.build?.cssTarget,
+        target: config.vite.build?.target
+      },
+      css: config.vite.css,
+      json: config.vite.json,
+      define: config.vite.define,
+      oxc: config.vite.oxc
+    },
+    experimental: {
+      clientPrerender: config.experimental.clientPrerender
+    }
+  };
+}
+export {
+  getConfigHashInput
+};

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

@@ -1,5 +1,5 @@
 import type { AstroLogger } from '../logger/core.js';
-import type { AstroPrerenderer, RouteToHeaders } from '../../types/public/index.js';
+import type { AstroPrerenderer, PrerenderResult, RouteToHeaders } from '../../types/public/index.js';
 import type { RouteData } from '../../types/public/internal.js';
 import { type BuildInternals } from './internal.js';
 import type { StaticBuildOptions } from './types.js';
@@ -13,6 +13,8 @@ export interface RenderPathResult {
     body: string | Uint8Array;
     outFile: URL;
     outFolder: URL;
+    /** Incremental-build metadata the prerenderer reported for this page, if any. */
+    metadata?: PrerenderResult['metadata'];
 }
 interface RenderToPathPayload {
     prerenderer: AstroPrerenderer;