astro 4.6.2 → 4.6.3

package/astro-jsx.d.ts

@@ -9,8 +9,6 @@
  * Adapted from React’s TypeScript definition from DefinitelyTyped.
  * @see https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react/index.d.ts
  */
-// BUG! Prettier 3.0 removes `declare`: https://github.com/prettier/prettier/issues/15207
-// prettier-ignore
 declare namespace astroHTML.JSX {
 	export type Child = Node | Node[] | string | number | boolean | null | undefined | unknown;
 	export type Children = Child | Child[];

package/components/Image.astro

@@ -1,5 +1,5 @@
 ---
-import { getImage, type LocalImageProps, type RemoteImageProps } from 'astro:assets';
+import { type LocalImageProps, type RemoteImageProps, getImage } from 'astro:assets';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 import type { HTMLAttributes } from '../types';
 

package/components/Picture.astro

@@ -1,5 +1,5 @@
 ---
-import { getImage, type LocalImageProps, type RemoteImageProps } from 'astro:assets';
+import { type LocalImageProps, type RemoteImageProps, getImage } from 'astro:assets';
 import type { GetImageResult, ImageOutputFormat } from '../dist/@types/astro';
 import { isESMImportedImage, resolveSrc } from '../dist/assets/utils/imageKind';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';

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

@@ -1394,18 +1394,18 @@ export interface AstroUserConfig {
              * When `true`, all URLs will display a language prefix.
              * URLs will be of the form `example.com/[locale]/content/` for every route, including the default language.
              * Localized folders are used for every language, including the default.
-         *
-           * ```js
-       * export default defineConfig({
-       * 	i18n: {
-       * 		defaultLocale: "en",
-       * 		locales: ["en", "fr", "pt-br", "es"],
-       * 		routing: {
-       * 			prefixDefaultLocale: true,
-       * 		}
-       * 	}
-       * })
-       * ```
+             *
+             * ```js
+             * export default defineConfig({
+             * 	i18n: {
+             * 		defaultLocale: "en",
+             * 		locales: ["en", "fr", "pt-br", "es"],
+             * 		routing: {
+             * 			prefixDefaultLocale: true,
+             * 		}
+             * 	}
+             * })
+             * ```
              */
             prefixDefaultLocale?: boolean;
             /**
@@ -1446,32 +1446,32 @@ export interface AstroUserConfig {
              * - `"pathname": The strategy is applied to the pathname of the URLs
              */
             strategy?: 'pathname';
-        } | 
+        }
         /**
-             *
-             * @docs
-             * @name i18n.routing.manual
-           * @kind h4
-             * @type {string}
-             * @version 4.6.0
-             * @description
-             * When this option is enabled, Astro will **disable** its i18n middleware so that you can implement your own custom logic. No other `routing` options (e.g. `prefixDefaultLocale`) may be configured with `routing: "manual"`.
-             *
-             * You will be responsible for writing your own routing logic, or executing Astro's i18n middleware manually alongside your own.
-           *
-             * ```js
-           * export default defineConfig({
-           * 	i18n: {
-           * 		defaultLocale: "en",
-           * 		locales: ["en", "fr", "pt-br", "es"],
-           * 		routing: {
-           * 			prefixDefaultLocale: true,
-           * 		}
-           * 	}
-           * })
-           * ```
-             */
-        'manual';
+         *
+         * @docs
+         * @name i18n.routing.manual
+         * @kind h4
+         * @type {string}
+         * @version 4.6.0
+         * @description
+         * When this option is enabled, Astro will **disable** its i18n middleware so that you can implement your own custom logic. No other `routing` options (e.g. `prefixDefaultLocale`) may be configured with `routing: "manual"`.
+         *
+         * You will be responsible for writing your own routing logic, or executing Astro's i18n middleware manually alongside your own.
+         *
+         * ```js
+         * export default defineConfig({
+         * 	i18n: {
+         * 		defaultLocale: "en",
+         * 		locales: ["en", "fr", "pt-br", "es"],
+         * 		routing: {
+         * 			prefixDefaultLocale: true,
+         * 		}
+         * 	}
+         * })
+         * ```
+         */
+         | 'manual';
         /**
          * @name i18n.domains
          * @type {Record<string, string> }
@@ -2524,6 +2524,7 @@ export interface AstroIntegration {
             dir: URL;
             routes: RouteData[];
             logger: AstroIntegrationLogger;
+            cacheManifest: boolean;
         }) => void | Promise<void>;
     };
 }

package/dist/assets/endpoint/generic.js

@@ -1,9 +1,9 @@
+import { imageConfig } from "astro:assets";
 import { isRemotePath } from "@astrojs/internal-helpers/path";
 import mime from "mime/lite.js";
 import { getConfiguredImageService } from "../internal.js";
 import { etag } from "../utils/etag.js";
 import { isRemoteAllowed } from "../utils/remotePattern.js";
-import { imageConfig } from "astro:assets";
 async function loadRemoteImage(src, headers) {
   try {
     const res = await fetch(src, {

package/dist/assets/endpoint/node.js

@@ -1,13 +1,13 @@
 import os from "node:os";
 import { isAbsolute } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { assetsDir, imageConfig, outDir } from "astro:assets";
 import { isRemotePath, removeQueryString } from "@astrojs/internal-helpers/path";
 import { readFile } from "fs/promises";
 import mime from "mime/lite.js";
 import { getConfiguredImageService } from "../internal.js";
 import { etag } from "../utils/etag.js";
 import { isRemoteAllowed } from "../utils/remotePattern.js";
-import { assetsDir, imageConfig, outDir } from "astro:assets";
 function replaceFileSystemReferences(src) {
   return os.platform().includes("win32") ? src.replace(/^\/@fs\//, "") : src.replace(/^\/@fs/, "");
 }

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

@@ -113,7 +113,9 @@ function assets({
               isServerLikeOutput(settings.config) ? settings.config.build.client : settings.config.outDir
             )
           )});
-					export const assetsDir = /* #__PURE__ */ new URL(${JSON.stringify(settings.config.build.assets)}, outDir);
+					export const assetsDir = /* #__PURE__ */ new URL(${JSON.stringify(
+            settings.config.build.assets
+          )}, outDir);
 					export const getImage = async (options) => await getImageInternal(options, imageConfig);
 				`;
         }

package/dist/cli/add/index.js

@@ -126,12 +126,12 @@ async function add(names, { flags }) {
           ["node", "astro add node"]
         ],
         Others: [
+          ["db", "astro add db"],
           ["tailwind", "astro add tailwind"],
-          ["image", "astro add image"],
           ["mdx", "astro add mdx"],
+          ["markdoc", "astro add markdoc"],
           ["partytown", "astro add partytown"],
-          ["sitemap", "astro add sitemap"],
-          ["prefetch", "astro add prefetch"]
+          ["sitemap", "astro add sitemap"]
         ]
       },
       description: `For more integrations, check out: ${cyan("https://astro.build/integrations")}`

package/dist/cli/install-package.js

@@ -26,7 +26,9 @@ async function getPackage(packageName, logger, options, otherDeps = []) {
   } catch (e) {
     if (options.optional)
       return void 0;
-    let message = `To continue, Astro requires the following dependency to be installed: ${bold(packageName)}.`;
+    let message = `To continue, Astro requires the following dependency to be installed: ${bold(
+      packageName
+    )}.`;
     if (ci.isCI) {
       message += ` Packages cannot be installed automatically in CI environments.`;
     }

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

@@ -0,0 +1 @@
+export declare const CHUNKS_PATH = "chunks/";

package/dist/core/build/consts.js

@@ -0,0 +1,4 @@
+const CHUNKS_PATH = "chunks/";
+export {
+  CHUNKS_PATH
+};

package/dist/core/build/index.js

@@ -146,7 +146,8 @@ class AstroBuilder {
       config: this.settings.config,
       pages: pageNames,
       routes: Object.values(allPages).flat().map((pageData) => pageData.route),
-      logging: this.logger
+      logging: this.logger,
+      cacheManifest: internals.cacheManifestUsed
     });
     if (this.logger.level && levels[this.logger.level()] <= levels["info"]) {
       await this.printStats({

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

@@ -66,6 +66,7 @@ export interface BuildInternals {
      */
     discoveredScripts: Set<string>;
     cachedClientEntries: string[];
+    cacheManifestUsed: boolean;
     propagatedStylesMap: Map<string, Set<StylesheetAsset>>;
     propagatedScriptsMap: Map<string, Set<string>>;
     staticFiles: Set<string>;

package/dist/core/build/internal.js

@@ -29,7 +29,8 @@ function createBuildInternals() {
     staticFiles: /* @__PURE__ */ new Set(),
     componentMetadata: /* @__PURE__ */ new Map(),
     ssrSplitEntryChunks: /* @__PURE__ */ new Map(),
-    entryPoints: /* @__PURE__ */ new Map()
+    entryPoints: /* @__PURE__ */ new Map(),
+    cacheManifestUsed: false
   };
 }
 function trackPageData(internals, component, pageData, componentModuleId, componentURL) {

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

@@ -1,4 +1,4 @@
-import type { Plugin as VitePlugin, Rollup } from 'vite';
+import type { Rollup, Plugin as VitePlugin } from 'vite';
 import type { BuildInternals } from './internal.js';
 import type { StaticBuildOptions, ViteBuildReturn } from './types.js';
 type RollupOutputArray = Extract<ViteBuildReturn, Array<any>>;

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

@@ -10,40 +10,53 @@ import {
   generateLookupMap
 } from "../../../content/vite-plugin-content-virtual-mod.js";
 import { isServerLikeOutput } from "../../../prerender/utils.js";
-import { joinPaths, removeFileExtension, removeLeadingForwardSlash } from "../../path.js";
+import { configPaths } from "../../config/index.js";
+import { emptyDir } from "../../fs/index.js";
+import {
+  appendForwardSlash,
+  joinPaths,
+  removeFileExtension,
+  removeLeadingForwardSlash
+} from "../../path.js";
 import { addRollupInput } from "../add-rollup-input.js";
+import { CHUNKS_PATH } from "../consts.js";
 import {} from "../internal.js";
 import { copyFiles } from "../static-build.js";
 import { encodeName } from "../util.js";
 import { extendManualChunks } from "./util.js";
 const CONTENT_CACHE_DIR = "./content/";
 const CONTENT_MANIFEST_FILE = "./manifest.json";
-const CONTENT_MANIFEST_VERSION = 0;
+const CONTENT_MANIFEST_VERSION = 1;
 const virtualEmptyModuleId = `virtual:empty-content`;
 const resolvedVirtualEmptyModuleId = `\0${virtualEmptyModuleId}`;
+const NO_MANIFEST_VERSION = -1;
 function createContentManifest() {
-  return { version: -1, entries: [], serverEntries: [], clientEntries: [] };
+  return {
+    version: NO_MANIFEST_VERSION,
+    entries: [],
+    serverEntries: [],
+    clientEntries: [],
+    lockfiles: "",
+    configs: ""
+  };
 }
-function vitePluginContent(opts, lookupMap, internals) {
+function vitePluginContent(opts, lookupMap, internals, cachedBuildOutput) {
   const { config } = opts.settings;
   const { cacheDir } = config;
   const distRoot = config.outDir;
   const distContentRoot = new URL("./content/", distRoot);
-  const cachedChunks = new URL("./chunks/", opts.settings.config.cacheDir);
-  const distChunks = new URL("./chunks/", opts.settings.config.outDir);
   const contentCacheDir = new URL(CONTENT_CACHE_DIR, cacheDir);
   const contentManifestFile = new URL(CONTENT_MANIFEST_FILE, contentCacheDir);
-  const cache = contentCacheDir;
-  const cacheTmp = new URL("./.tmp/", cache);
+  const cacheTmp = new URL("./.tmp/", contentCacheDir);
   let oldManifest = createContentManifest();
   let newManifest = createContentManifest();
   let entries;
   let injectedEmptyFile = false;
+  let currentManifestState = "valid";
   if (fsMod.existsSync(contentManifestFile)) {
     try {
       const data = fsMod.readFileSync(contentManifestFile, { encoding: "utf8" });
       oldManifest = JSON.parse(data);
-      internals.cachedClientEntries = oldManifest.clientEntries;
     } catch {
     }
   }
@@ -53,6 +66,30 @@ function vitePluginContent(opts, lookupMap, internals) {
       let newOptions = Object.assign({}, options);
       newManifest = await generateContentManifest(opts, lookupMap);
       entries = getEntriesFromManifests(oldManifest, newManifest);
+      currentManifestState = manifestState(oldManifest, newManifest);
+      if (currentManifestState === "valid") {
+        internals.cachedClientEntries = oldManifest.clientEntries;
+      } else {
+        let logReason = "";
+        switch (currentManifestState) {
+          case "config-mismatch":
+            logReason = "Astro config has changed";
+            break;
+          case "lockfile-mismatch":
+            logReason = "Lockfiles have changed";
+            break;
+          case "no-entries":
+            logReason = "No content collections entries cached";
+            break;
+          case "version-mismatch":
+            logReason = "The cache manifest version has changed";
+            break;
+          case "no-manifest":
+            logReason = "No content manifest was found in the cache";
+            break;
+        }
+        opts.logger.info("build", `Cache invalid, rebuilding from source. Reason: ${logReason}.`);
+      }
       for (const { type, entry } of entries.buildFromSource) {
         const fileURL = encodeURI(joinPaths(opts.settings.config.root.toString(), entry));
         const input = fileURLToPath(fileURL);
@@ -62,8 +99,12 @@ function vitePluginContent(opts, lookupMap, internals) {
         }
         newOptions = addRollupInput(newOptions, inputs);
       }
-      if (fsMod.existsSync(cachedChunks)) {
-        await copyFiles(cachedChunks, distChunks, true);
+      if (currentManifestState === "valid") {
+        for (const { cached, dist } of cachedBuildOutput) {
+          if (fsMod.existsSync(cached)) {
+            await copyFiles(cached, dist, true);
+          }
+        }
       }
       if (entries.buildFromSource.length === 0) {
         newOptions = addRollupInput(newOptions, [virtualEmptyModuleId]);
@@ -152,15 +193,17 @@ export default {}`
       ]);
       newManifest.serverEntries = Array.from(serverComponents);
       newManifest.clientEntries = Array.from(clientComponents);
+      const cacheExists = fsMod.existsSync(contentCacheDir);
+      if (cacheExists && currentManifestState !== "valid") {
+        emptyDir(contentCacheDir);
+      }
       await fsMod.promises.mkdir(contentCacheDir, { recursive: true });
       await fsMod.promises.writeFile(contentManifestFile, JSON.stringify(newManifest), {
         encoding: "utf8"
       });
-      const cacheExists = fsMod.existsSync(cache);
-      fsMod.mkdirSync(cache, { recursive: true });
       await fsMod.promises.mkdir(cacheTmp, { recursive: true });
       await copyFiles(distContentRoot, cacheTmp, true);
-      if (cacheExists) {
+      if (cacheExists && currentManifestState === "valid") {
         await copyFiles(contentCacheDir, distContentRoot, false);
       }
       await copyFiles(cacheTmp, contentCacheDir);
@@ -186,11 +229,11 @@ function findEntryFromSrcRelativePath(lookupMap, srcRelativePath) {
   }
 }
 function getEntriesFromManifests(oldManifest, newManifest) {
-  const { version: oldVersion, entries: oldEntries } = oldManifest;
-  const { version: newVersion, entries: newEntries } = newManifest;
+  const { entries: oldEntries } = oldManifest;
+  const { entries: newEntries } = newManifest;
   let entries = { restoreFromCache: [], buildFromSource: [] };
   const newEntryMap = new Map(newEntries);
-  if (oldVersion !== newVersion || oldEntries.length === 0) {
+  if (manifestState(oldManifest, newManifest) !== "valid") {
     entries.buildFromSource = Array.from(newEntryMap.keys());
     return entries;
   }
@@ -206,13 +249,27 @@ function getEntriesFromManifests(oldManifest, newManifest) {
   }
   return entries;
 }
+function manifestState(oldManifest, newManifest) {
+  if (oldManifest.version === NO_MANIFEST_VERSION) {
+    return "no-manifest";
+  }
+  if (oldManifest.version !== newManifest.version) {
+    return "version-mismatch";
+  }
+  if (oldManifest.entries.length === 0) {
+    return "no-entries";
+  }
+  if (oldManifest.lockfiles !== newManifest.lockfiles || newManifest.lockfiles === "") {
+    return "lockfile-mismatch";
+  }
+  if (oldManifest.configs !== newManifest.configs) {
+    return "config-mismatch";
+  }
+  return "valid";
+}
 async function generateContentManifest(opts, lookupMap) {
-  let manifest = {
-    version: CONTENT_MANIFEST_VERSION,
-    entries: [],
-    serverEntries: [],
-    clientEntries: []
-  };
+  let manifest = createContentManifest();
+  manifest.version = CONTENT_MANIFEST_VERSION;
   const limit = pLimit(10);
   const promises = [];
   for (const [collection, { type, entries }] of Object.entries(lookupMap)) {
@@ -227,19 +284,65 @@ async function generateContentManifest(opts, lookupMap) {
       );
     }
   }
+  const [lockfiles, configs] = await Promise.all([
+    lockfilesHash(opts.settings.config.root),
+    configHash(opts.settings.config.root)
+  ]);
+  manifest.lockfiles = lockfiles;
+  manifest.configs = configs;
   await Promise.all(promises);
   return manifest;
 }
-function checksum(data) {
-  return createHash("sha1").update(data).digest("base64");
+async function pushBufferInto(fileURL, buffers) {
+  try {
+    const handle = await fsMod.promises.open(fileURL, "r");
+    const data = await handle.readFile();
+    buffers.push(data);
+    await handle.close();
+  } catch {
+  }
+}
+async function lockfilesHash(root) {
+  const lockfiles = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
+  const datas = [];
+  const promises = [];
+  for (const lockfileName of lockfiles) {
+    const fileURL = new URL(`./${lockfileName}`, root);
+    promises.push(pushBufferInto(fileURL, datas));
+  }
+  await Promise.all(promises);
+  return checksum(...datas);
+}
+async function configHash(root) {
+  const configFileNames = configPaths;
+  for (const configPath of configFileNames) {
+    try {
+      const fileURL = new URL(`./${configPath}`, root);
+      const data = await fsMod.promises.readFile(fileURL);
+      const hash = checksum(data);
+      return hash;
+    } catch {
+    }
+  }
+  return checksum(`export default {}`);
+}
+function checksum(...datas) {
+  const hash = createHash("sha1");
+  datas.forEach((data) => hash.update(data));
+  return hash.digest("base64");
 }
 function collectionTypeToFlag(type) {
   const name = type[0].toUpperCase() + type.slice(1);
   return `astro${name}CollectionEntry`;
 }
 function pluginContent(opts, internals) {
-  const cachedChunks = new URL("./chunks/", opts.settings.config.cacheDir);
-  const distChunks = new URL("./chunks/", opts.settings.config.outDir);
+  const { cacheDir, outDir } = opts.settings.config;
+  const chunksFolder = "./" + CHUNKS_PATH;
+  const assetsFolder = "./" + appendForwardSlash(opts.settings.config.build.assets);
+  const cachedBuildOutput = [
+    { cached: new URL(chunksFolder, cacheDir), dist: new URL(chunksFolder, outDir) },
+    { cached: new URL(assetsFolder, cacheDir), dist: new URL(assetsFolder, outDir) }
+  ];
   return {
     targets: ["server"],
     hooks: {
@@ -252,7 +355,7 @@ function pluginContent(opts, internals) {
         }
         const lookupMap = await generateLookupMap({ settings: opts.settings, fs: fsMod });
         return {
-          vitePlugin: vitePluginContent(opts, lookupMap, internals)
+          vitePlugin: vitePluginContent(opts, lookupMap, internals, cachedBuildOutput)
         };
       },
       async "build:post"() {
@@ -262,8 +365,10 @@ function pluginContent(opts, internals) {
         if (isServerLikeOutput(opts.settings.config)) {
           return;
         }
-        if (fsMod.existsSync(distChunks)) {
-          await copyFiles(distChunks, cachedChunks, true);
+        for (const { cached, dist } of cachedBuildOutput) {
+          if (fsMod.existsSync(dist)) {
+            await copyFiles(dist, cached, true);
+          }
         }
       }
     }

package/dist/core/build/plugins/util.d.ts

@@ -1,4 +1,4 @@
-import type { BuildOptions, Plugin as VitePlugin, Rollup } from 'vite';
+import type { BuildOptions, Rollup, Plugin as VitePlugin } from 'vite';
 type OutputOptionsHook = Extract<VitePlugin['outputOptions'], Function>;
 type OutputOptions = Parameters<OutputOptionsHook>[0];
 type ExtendManualChunksHooks = {

package/dist/core/build/static-build.d.ts

@@ -6,7 +6,7 @@ export declare function viteBuild(opts: StaticBuildOptions): Promise<{
     ssrOutputChunkNames: string[];
 }>;
 export declare function staticBuild(opts: StaticBuildOptions, internals: BuildInternals, ssrOutputChunkNames: string[]): Promise<void>;
-export declare function copyFiles(fromFolder: URL, toFolder: URL, includeDotfiles?: boolean): Promise<void>;
+export declare function copyFiles(fromFolder: URL, toFolder: URL, includeDotfiles?: boolean): Promise<void[] | undefined>;
 /**
  * This function takes the virtual module name of any page entrypoint and
  * transforms it to generate a final `.mjs` output file.

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

@@ -21,6 +21,7 @@ import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { routeIsRedirect } from "../redirects/index.js";
 import { getOutDirWithinCwd } from "./common.js";
+import { CHUNKS_PATH } from "./consts.js";
 import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { createPluginContainer } from "./plugin.js";
@@ -146,7 +147,7 @@ async function ssrBuild(opts, internals, input, container) {
           // We need to keep these separate
           chunkFileNames(chunkInfo) {
             const { name } = chunkInfo;
-            let prefix = "chunks/";
+            let prefix = CHUNKS_PATH;
             let suffix = "_[hash].mjs";
             if (isContentCache) {
               prefix += `${buildID}/`;
@@ -345,7 +346,7 @@ async function copyFiles(fromFolder, toFolder, includeDotfiles = false) {
   });
   if (files.length === 0)
     return;
-  await Promise.all(
+  return await Promise.all(
     files.map(async function copyFile(filename) {
       const from = new URL(filename, fromFolder);
       const to = new URL(filename, toFolder);

package/dist/core/config/config.d.ts

@@ -7,6 +7,7 @@ export declare function validateConfig(userConfig: any, root: string, cmd: strin
 /** Convert the generic "yargs" flag object into our own, custom TypeScript object. */
 export declare function resolveFlags(flags: Partial<Flags>): CLIFlags;
 export declare function resolveRoot(cwd?: string | URL): string;
+export declare const configPaths: readonly string[];
 interface ResolveConfigPathOptions {
     root: string;
     configFile?: string;

package/dist/core/config/config.js

@@ -45,15 +45,16 @@ function resolveRoot(cwd) {
   }
   return cwd ? path.resolve(cwd) : process.cwd();
 }
+const configPaths = Object.freeze([
+  "astro.config.mjs",
+  "astro.config.js",
+  "astro.config.ts",
+  "astro.config.mts",
+  "astro.config.cjs",
+  "astro.config.cts"
+]);
 async function search(fsMod, root) {
-  const paths = [
-    "astro.config.mjs",
-    "astro.config.js",
-    "astro.config.ts",
-    "astro.config.mts",
-    "astro.config.cjs",
-    "astro.config.cts"
-  ].map((p) => path.join(root, p));
+  const paths = configPaths.map((p) => path.join(root, p));
   for (const file of paths) {
     if (fsMod.existsSync(file)) {
       return file;
@@ -121,6 +122,7 @@ async function resolveConfig(inlineConfig, command, fsMod = fs) {
   return { userConfig, astroConfig };
 }
 export {
+  configPaths,
   resolveConfig,
   resolveConfigPath,
   resolveFlags,

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

@@ -1,4 +1,4 @@
-export { resolveConfig, resolveConfigPath, resolveFlags, resolveRoot } from './config.js';
+export { configPaths, resolveConfig, resolveConfigPath, resolveFlags, resolveRoot, } from './config.js';
 export { createNodeLogger } from './logging.js';
 export { mergeConfig } from './merge.js';
 export type { AstroConfigType } from './schema.js';

package/dist/core/config/index.js

@@ -1,9 +1,16 @@
-import { resolveConfig, resolveConfigPath, resolveFlags, resolveRoot } from "./config.js";
+import {
+  configPaths,
+  resolveConfig,
+  resolveConfigPath,
+  resolveFlags,
+  resolveRoot
+} from "./config.js";
 import { createNodeLogger } from "./logging.js";
 import { mergeConfig } from "./merge.js";
 import { createSettings } from "./settings.js";
 import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
 export {
+  configPaths,
   createNodeLogger,
   createSettings,
   loadTSConfig,

package/dist/core/config/schema.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, ShikiConfig } from '@astrojs/markdown-remark';
+import type { ShikiConfig, RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype } from '@astrojs/markdown-remark';
 import type { ViteUserConfig } from '../../@types/astro.js';
 import type { OutgoingHttpHeaders } from 'node:http';
 import { z } from 'zod';

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "4.6.2";
+const ASTRO_VERSION = "4.6.3";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
 const DEFAULT_404_COMPONENT = "astro-default-404";

package/dist/core/dev/dev.js

@@ -23,7 +23,7 @@ async function dev(inlineConfig) {
       base: restart.container.settings.config.base
     })
   );
-  const currentVersion = "4.6.2";
+  const currentVersion = "4.6.3";
   if (currentVersion.includes("-")) {
     logger.warn("SKIP_FORMAT", msg.prerelease({ currentVersion }));
   }

package/dist/core/messages.js

@@ -36,7 +36,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "4.6.2";
+  const version = "4.6.3";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -261,7 +261,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"4.6.2"}`
+        `v${"4.6.3"}`
       )} ${headline}`
     );
   }

package/dist/core/render-context.d.ts

@@ -33,7 +33,16 @@ export declare class RenderContext {
     render(componentInstance: ComponentInstance | undefined): Promise<Response>;
     createAPIContext(props: APIContext['props']): APIContext;
     createResult(mod: ComponentInstance): Promise<SSRResult>;
-    createAstro(result: SSRResult, astroGlobalPartial: AstroGlobalPartial, props: Record<string, any>, slotValues: Record<string, any> | null): AstroGlobal;
+    /**
+     * The Astro global is sourced in 3 different phases:
+     * - **Static**: `.generator` and `.glob` is printed by the compiler, instantiated once per process per astro file
+     * - **Page-level**: `.request`, `.cookies`, `.locals` etc. These remain the same for the duration of the request.
+     * - **Component-level**: `.props`, `.slots`, and `.self` are unique to each _use_ of each component.
+     *
+     * The page level partial is used as the prototype of the user-visible `Astro` global object, which is instantiated once per use of a component.
+     */
+    createAstro(result: SSRResult, astroStaticPartial: AstroGlobalPartial, props: Record<string, any>, slotValues: Record<string, any> | null): AstroGlobal;
+    createAstroPagePartial(result: SSRResult, astroStaticPartial: AstroGlobalPartial): Omit<AstroGlobal, 'props' | 'self' | 'slots'>;
     clientAddress(): string;
     computeCurrentLocale(): string | undefined;
     computePreferredLocale(): string | undefined;

package/dist/core/render-context.js

@@ -202,7 +202,41 @@ class RenderContext {
     };
     return result;
   }
-  createAstro(result, astroGlobalPartial, props, slotValues) {
+  #astroPagePartial;
+  /**
+   * The Astro global is sourced in 3 different phases:
+   * - **Static**: `.generator` and `.glob` is printed by the compiler, instantiated once per process per astro file
+   * - **Page-level**: `.request`, `.cookies`, `.locals` etc. These remain the same for the duration of the request.
+   * - **Component-level**: `.props`, `.slots`, and `.self` are unique to each _use_ of each component.
+   *
+   * The page level partial is used as the prototype of the user-visible `Astro` global object, which is instantiated once per use of a component.
+   */
+  createAstro(result, astroStaticPartial, props, slotValues) {
+    const astroPagePartial = this.#astroPagePartial ??= this.createAstroPagePartial(
+      result,
+      astroStaticPartial
+    );
+    const astroComponentPartial = { props, self: null };
+    const Astro = Object.assign(
+      Object.create(astroPagePartial),
+      astroComponentPartial
+    );
+    let _slots;
+    Object.defineProperty(Astro, "slots", {
+      get: () => {
+        if (!_slots) {
+          _slots = new Slots(
+            result,
+            slotValues,
+            this.pipeline.logger
+          );
+        }
+        return _slots;
+      }
+    });
+    return Astro;
+  }
+  createAstroPagePartial(result, astroStaticPartial) {
     const renderContext = this;
     const { cookies, locals, params, pipeline, request, url } = this;
     const { response } = result;
@@ -214,10 +248,9 @@ class RenderContext {
       }
       return new Response(null, { status, headers: { Location: path } });
     };
-    const slots = new Slots(result, slotValues, pipeline.logger);
-    const astroGlobalCombined = {
-      generator: astroGlobalPartial.generator,
-      glob: astroGlobalPartial.glob,
+    return {
+      generator: astroStaticPartial.generator,
+      glob: astroStaticPartial.glob,
       cookies,
       get clientAddress() {
         return renderContext.clientAddress();
@@ -232,16 +265,13 @@ class RenderContext {
       get preferredLocaleList() {
         return renderContext.computePreferredLocaleList();
       },
-      props,
       locals,
       redirect,
       request,
       response,
-      slots,
       site: pipeline.site,
       url
     };
-    return astroGlobalCombined;
   }
   clientAddress() {
     const { pipeline, request } = this;

package/dist/integrations/index.d.ts

@@ -57,7 +57,8 @@ type RunHookBuildDone = {
     pages: string[];
     routes: RouteData[];
     logging: Logger;
+    cacheManifest: boolean;
 };
-export declare function runHookBuildDone({ config, pages, routes, logging }: RunHookBuildDone): Promise<void>;
+export declare function runHookBuildDone({ config, pages, routes, logging, cacheManifest, }: RunHookBuildDone): Promise<void>;
 export declare function isFunctionPerRouteEnabled(adapter: AstroAdapter | undefined): boolean;
 export {};

package/dist/integrations/index.js

@@ -349,7 +349,13 @@ async function runHookBuildGenerated({
     }
   }
 }
-async function runHookBuildDone({ config, pages, routes, logging }) {
+async function runHookBuildDone({
+  config,
+  pages,
+  routes,
+  logging,
+  cacheManifest
+}) {
   const dir = isServerLikeOutput(config) ? config.build.client : config.outDir;
   await fs.promises.mkdir(dir, { recursive: true });
   for (const integration of config.integrations) {
@@ -362,7 +368,8 @@ async function runHookBuildDone({ config, pages, routes, logging }) {
           pages: pages.map((p) => ({ pathname: p })),
           dir,
           routes,
-          logger
+          logger,
+          cacheManifest
         }),
         logger: logging
       });

package/dist/runtime/client/dev-toolbar/apps/settings.js

@@ -177,7 +177,9 @@ var settings_default = {
               if (placement === settings.config[setting.settingKey]) {
                 option.selected = true;
               }
-              option.textContent = `${placement.slice(0, 1).toUpperCase()}${placement.slice(1)}`.replace("-", " ");
+              option.textContent = `${placement.slice(0, 1).toUpperCase()}${placement.slice(
+                1
+              )}`.replace("-", " ");
               astroSelect.append(option);
             });
             astroSelect.element.addEventListener("change", setting.changeEvent);

package/dist/runtime/client/dev-toolbar/entrypoint.js

@@ -1,5 +1,5 @@
-import { settings } from "./settings.js";
 import { loadDevToolbarApps } from "astro:dev-toolbar";
+import { settings } from "./settings.js";
 let overlay;
 document.addEventListener("DOMContentLoaded", async () => {
   const [

package/dist/runtime/client/dev-toolbar/toolbar.js

@@ -248,7 +248,9 @@ class AstroDevToolbar extends HTMLElement {
       this.apps.find((app) => app.builtIn && app.id === "astro:more")
     ) : ""}
 					<div class="separator"></div>
-					${this.getAppTemplate(this.apps.find((app) => app.builtIn && app.id === "astro:settings"))}
+					${this.getAppTemplate(
+      this.apps.find((app) => app.builtIn && app.id === "astro:settings")
+    )}
 				</div>
 			</div>
 			<div id="dev-bar-hitbox-below"></div>

package/dist/transitions/router.js

@@ -203,8 +203,10 @@ async function updateDOM(preparationEvent, options, historyState, fallback) {
     if (activeElement) {
       activeElement.focus();
       if (activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement) {
-        activeElement.selectionStart = start;
-        activeElement.selectionEnd = end;
+        if (typeof start === "number")
+          activeElement.selectionStart = start;
+        if (typeof end === "number")
+          activeElement.selectionEnd = end;
       }
     }
   };

package/dist/vite-plugin-astro/index.js

@@ -54,10 +54,17 @@ function astro({ settings, logger }) {
       }
       const filename = normalizePath(normalizeFilename(parsedId.filename, config.root));
       let compileMetadata = astroFileToCompileMetadata.get(filename);
-      if (!compileMetadata && server) {
-        const code = await loadId(server.pluginContainer, filename);
-        if (code != null)
-          await compile(code, filename);
+      if (!compileMetadata) {
+        if (server) {
+          const code = await loadId(server.pluginContainer, filename);
+          if (code != null)
+            await compile(code, filename);
+        } else if (config.experimental.contentCollectionCache) {
+          await this.load({
+            id: filename,
+            resolveDependencies: false
+          });
+        }
         compileMetadata = astroFileToCompileMetadata.get(filename);
       }
       if (!compileMetadata) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "4.6.2",
+  "version": "4.6.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",