astro 3.4.4 → 3.5.1

package/dist/content/vite-plugin-content-virtual-mod.d.ts

@@ -1,22 +1,27 @@
 /// <reference types="node" resolution-mode="require"/>
-import fsMod from 'node:fs';
-import type { Plugin } from 'vite';
-import type { AstroSettings, ContentEntryType } from '../@types/astro.js';
-import { type ContentPaths } from './utils.js';
+import nodeFs from 'node:fs';
+import { type Plugin } from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import { type ContentLookupMap } from './utils.js';
 interface AstroContentVirtualModPluginParams {
     settings: AstroSettings;
+    fs: typeof nodeFs;
 }
-export declare function astroContentVirtualModPlugin({ settings, }: AstroContentVirtualModPluginParams): Plugin;
+export declare function astroContentVirtualModPlugin({ settings, fs, }: AstroContentVirtualModPluginParams): Plugin;
+export declare function generateContentEntryFile({ settings, lookupMap, IS_DEV, IS_SERVER, }: {
+    settings: AstroSettings;
+    fs: typeof nodeFs;
+    lookupMap: ContentLookupMap;
+    IS_DEV: boolean;
+    IS_SERVER: boolean;
+}): Promise<string>;
 /**
  * Generate a map from a collection + slug to the local file path.
  * This is used internally to resolve entry imports when using `getEntry()`.
  * @see `content-module.template.mjs`
  */
-export declare function getStringifiedLookupMap({ contentPaths, contentEntryConfigByExt, dataEntryExts, root, fs, }: {
-    contentEntryConfigByExt: Map<string, ContentEntryType>;
-    dataEntryExts: string[];
-    contentPaths: Pick<ContentPaths, 'contentDir' | 'config'>;
-    root: URL;
-    fs: typeof fsMod;
-}): Promise<string>;
+export declare function generateLookupMap({ settings, fs, }: {
+    settings: AstroSettings;
+    fs: typeof nodeFs;
+}): Promise<ContentLookupMap>;
 export {};

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

@@ -1,12 +1,21 @@
 import glob from "fast-glob";
-import fsMod from "node:fs";
+import nodeFs from "node:fs";
 import { extname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import pLimit from "p-limit";
+import {} from "vite";
+import { encodeName } from "../core/build/util.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { appendForwardSlash } from "../core/path.js";
+import { appendForwardSlash, removeFileExtension } from "../core/path.js";
 import { rootRelativePath } from "../core/util.js";
-import { VIRTUAL_MODULE_ID } from "./consts.js";
+import { isServerLikeOutput } from "../prerender/utils.js";
+import {
+  CONTENT_FLAG,
+  CONTENT_RENDER_FLAG,
+  DATA_FLAG,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  VIRTUAL_MODULE_ID
+} from "./consts.js";
 import {
   getContentEntryIdAndSlug,
   getContentPaths,
@@ -19,68 +28,140 @@ import {
   getExtGlob
 } from "./utils.js";
 function astroContentVirtualModPlugin({
-  settings
+  settings,
+  fs
 }) {
-  const contentPaths = getContentPaths(settings.config);
-  const relContentDir = rootRelativePath(settings.config.root, contentPaths.contentDir);
-  const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
-  const contentEntryExts = [...contentEntryConfigByExt.keys()];
-  const dataEntryExts = getDataEntryExts(settings);
-  const virtualModContents = fsMod.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace(
-    "@@COLLECTION_NAME_BY_REFERENCE_KEY@@",
-    new URL("reference-map.json", contentPaths.cacheDir).pathname
-  ).replace("@@CONTENT_DIR@@", relContentDir).replace(
-    "'@@CONTENT_ENTRY_GLOB_PATH@@'",
-    JSON.stringify(globWithUnderscoresIgnored(relContentDir, contentEntryExts))
-  ).replace(
-    "'@@DATA_ENTRY_GLOB_PATH@@'",
-    JSON.stringify(globWithUnderscoresIgnored(relContentDir, dataEntryExts))
-  ).replace(
-    "'@@RENDER_ENTRY_GLOB_PATH@@'",
-    JSON.stringify(
-      globWithUnderscoresIgnored(
-        relContentDir,
-        /** Note: data collections excluded */
-        contentEntryExts
-      )
-    )
-  );
-  const astroContentVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
+  let IS_DEV = false;
+  const IS_SERVER = isServerLikeOutput(settings.config);
   return {
     name: "astro-content-virtual-mod-plugin",
+    enforce: "pre",
+    configResolved(config) {
+      IS_DEV = config.mode === "development";
+    },
     resolveId(id) {
       if (id === VIRTUAL_MODULE_ID) {
-        return astroContentVirtualModuleId;
+        if (!settings.config.experimental.contentCollectionCache) {
+          return RESOLVED_VIRTUAL_MODULE_ID;
+        }
+        if (IS_DEV || IS_SERVER) {
+          return RESOLVED_VIRTUAL_MODULE_ID;
+        } else {
+          return { id: RESOLVED_VIRTUAL_MODULE_ID, external: true };
+        }
       }
     },
     async load(id) {
-      if (id === astroContentVirtualModuleId) {
-        const stringifiedLookupMap = await getStringifiedLookupMap({
-          fs: fsMod,
-          contentPaths,
-          contentEntryConfigByExt,
-          dataEntryExts,
-          root: settings.config.root
+      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+        const lookupMap = await generateLookupMap({
+          settings,
+          fs
         });
+        const code = await generateContentEntryFile({ settings, fs, lookupMap, IS_DEV, IS_SERVER });
         return {
-          code: virtualModContents.replace(
-            "/* @@LOOKUP_MAP_ASSIGNMENT@@ */",
-            `lookupMap = ${stringifiedLookupMap};`
-          )
+          code,
+          meta: {
+            astro: {
+              hydratedComponents: [],
+              clientOnlyComponents: [],
+              scripts: [],
+              containsHead: true,
+              propagation: "in-tree",
+              pageOptions: {}
+            }
+          }
         };
       }
+    },
+    renderChunk(code, chunk) {
+      if (!settings.config.experimental.contentCollectionCache) {
+        return;
+      }
+      if (code.includes(RESOLVED_VIRTUAL_MODULE_ID)) {
+        const depth = chunk.fileName.split("/").length - 1;
+        const prefix = depth > 0 ? "../".repeat(depth) : "./";
+        return code.replaceAll(RESOLVED_VIRTUAL_MODULE_ID, `${prefix}content/entry.mjs`);
+      }
     }
   };
 }
-async function getStringifiedLookupMap({
-  contentPaths,
-  contentEntryConfigByExt,
-  dataEntryExts,
-  root,
+async function generateContentEntryFile({
+  settings,
+  lookupMap,
+  IS_DEV,
+  IS_SERVER
+}) {
+  const contentPaths = getContentPaths(settings.config);
+  const relContentDir = rootRelativePath(settings.config.root, contentPaths.contentDir);
+  let contentEntryGlobResult;
+  let dataEntryGlobResult;
+  let renderEntryGlobResult;
+  if (IS_DEV || IS_SERVER || !settings.config.experimental.contentCollectionCache) {
+    const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
+    const contentEntryExts = [...contentEntryConfigByExt.keys()];
+    const dataEntryExts = getDataEntryExts(settings);
+    const createGlob = (value, flag) => `import.meta.glob(${JSON.stringify(value)}, { query: { ${flag}: true } })`;
+    contentEntryGlobResult = createGlob(
+      globWithUnderscoresIgnored(relContentDir, contentEntryExts),
+      CONTENT_FLAG
+    );
+    dataEntryGlobResult = createGlob(
+      globWithUnderscoresIgnored(relContentDir, dataEntryExts),
+      DATA_FLAG
+    );
+    renderEntryGlobResult = createGlob(
+      globWithUnderscoresIgnored(relContentDir, contentEntryExts),
+      CONTENT_RENDER_FLAG
+    );
+  } else {
+    contentEntryGlobResult = getStringifiedCollectionFromLookup(
+      "content",
+      relContentDir,
+      lookupMap
+    );
+    dataEntryGlobResult = getStringifiedCollectionFromLookup("data", relContentDir, lookupMap);
+    renderEntryGlobResult = getStringifiedCollectionFromLookup("render", relContentDir, lookupMap);
+  }
+  const virtualModContents = nodeFs.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace("'@@CONTENT_ENTRY_GLOB_PATH@@'", contentEntryGlobResult).replace("'@@DATA_ENTRY_GLOB_PATH@@'", dataEntryGlobResult).replace("'@@RENDER_ENTRY_GLOB_PATH@@'", renderEntryGlobResult).replace("/* @@LOOKUP_MAP_ASSIGNMENT@@ */", `lookupMap = ${JSON.stringify(lookupMap)};`);
+  return virtualModContents;
+}
+function getStringifiedCollectionFromLookup(wantedType, relContentDir, lookupMap) {
+  let str = "{";
+  let normalize = (slug) => slug;
+  if (process.env.NODE_ENV === "production") {
+    const suffix = wantedType === "render" ? ".entry.mjs" : ".mjs";
+    normalize = (slug) => `${removeFileExtension(encodeName(slug)).replace(relContentDir, "./")}${suffix}`;
+  } else {
+    let suffix = "";
+    if (wantedType === "content")
+      suffix = CONTENT_FLAG;
+    else if (wantedType === "data")
+      suffix = DATA_FLAG;
+    else if (wantedType === "render")
+      suffix = CONTENT_RENDER_FLAG;
+    normalize = (slug) => `${slug}?${suffix}`;
+  }
+  for (const { type, entries } of Object.values(lookupMap)) {
+    if (type === wantedType || wantedType === "render" && type === "content") {
+      for (const slug of Object.values(entries)) {
+        str += `
+  "${slug}": () => import("${normalize(slug)}"),`;
+      }
+    }
+  }
+  str += "\n}";
+  return str;
+}
+async function generateLookupMap({
+  settings,
   fs
 }) {
+  const { root } = settings.config;
+  const contentPaths = getContentPaths(settings.config);
+  const relContentDir = rootRelativePath(root, contentPaths.contentDir, false);
+  const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
+  const dataEntryExts = getDataEntryExts(settings);
   const { contentDir } = contentPaths;
-  const relContentDir = rootRelativePath(root, contentDir, false);
   const contentEntryExts = [...contentEntryConfigByExt.keys()];
   let lookupMap = {};
   const contentGlob = await glob(
@@ -88,10 +169,7 @@ async function getStringifiedLookupMap({
     {
       absolute: true,
       cwd: fileURLToPath(root),
-      fs: {
-        readdir: fs.readdir.bind(fs),
-        readdirSync: fs.readdirSync.bind(fs)
-      }
+      fs
     }
   );
   const limit = pLimit(10);
@@ -156,12 +234,8 @@ async function getStringifiedLookupMap({
     );
   }
   await Promise.all(promises);
-  return JSON.stringify(lookupMap);
+  return lookupMap;
 }
-const UnexpectedLookupMapError = new AstroError({
-  ...AstroErrorData.UnknownContentCollectionError,
-  message: `Unexpected error while parsing content entry IDs and slugs.`
-});
 function globWithUnderscoresIgnored(relContentDir, exts) {
   const extGlob = getExtGlob(exts);
   const contentDir = appendForwardSlash(relContentDir);
@@ -171,7 +245,12 @@ function globWithUnderscoresIgnored(relContentDir, exts) {
     `!${contentDir}**/_*${extGlob}`
   ];
 }
+const UnexpectedLookupMapError = new AstroError({
+  ...AstroErrorData.UnknownContentCollectionError,
+  message: `Unexpected error while parsing content entry IDs and slugs.`
+});
 export {
   astroContentVirtualModPlugin,
-  getStringifiedLookupMap
+  generateContentEntryFile,
+  generateLookupMap
 };

package/dist/core/app/index.js

@@ -1,6 +1,8 @@
+import { createI18nMiddleware } from "../../i18n/middleware.js";
 import { getSetCookiesFromResponse } from "../cookies/index.js";
 import { consoleLogDestination } from "../logger/console.js";
 import { AstroIntegrationLogger, Logger } from "../logger/core.js";
+import { sequence } from "../middleware/index.js";
 import {
   collapseDuplicateSlashes,
   prependForwardSlash,
@@ -128,8 +130,19 @@ class App {
     );
     let response;
     try {
-      if (mod.onRequest) {
-        this.#pipeline.setMiddlewareFunction(mod.onRequest);
+      let i18nMiddleware = createI18nMiddleware(this.#manifest.i18n, this.#manifest.base);
+      if (i18nMiddleware) {
+        if (mod.onRequest) {
+          this.#pipeline.setMiddlewareFunction(
+            sequence(i18nMiddleware, mod.onRequest)
+          );
+        } else {
+          this.#pipeline.setMiddlewareFunction(i18nMiddleware);
+        }
+      } else {
+        if (mod.onRequest) {
+          this.#pipeline.setMiddlewareFunction(mod.onRequest);
+        }
       }
       response = await this.#pipeline.renderRoute(renderContext, pageModule);
     } catch (err) {
@@ -169,7 +182,8 @@ class App {
         route: routeData,
         status,
         env: this.#pipeline.env,
-        mod: handler
+        mod: handler,
+        locales: this.#manifest.i18n ? this.#manifest.i18n.locales : void 0
       });
     } else {
       const pathname = prependForwardSlash(this.removeBase(url.pathname));
@@ -200,7 +214,8 @@ class App {
         route: routeData,
         status,
         mod,
-        env: this.#pipeline.env
+        env: this.#pipeline.env,
+        locales: this.#manifest.i18n ? this.#manifest.i18n.locales : void 0
       });
     }
   }

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

@@ -42,6 +42,13 @@ export type SSRManifest = {
     componentMetadata: SSRResult['componentMetadata'];
     pageModule?: SinglePageBuiltModule;
     pageMap?: Map<ComponentPath, ImportComponentInstance>;
+    i18n: SSRManifestI18n | undefined;
+};
+export type SSRManifestI18n = {
+    fallback?: Record<string, string>;
+    routingStrategy?: 'prefix-always' | 'prefix-other-locales';
+    locales: string[];
+    defaultLocale: string;
 };
 export type SerializedSSRManifest = Omit<SSRManifest, 'routes' | 'assets' | 'componentMetadata' | 'clientDirectives'> & {
     routes: SerializedRouteInfo[];
@@ -49,4 +56,3 @@ export type SerializedSSRManifest = Omit<SSRManifest, 'routes' | 'assets' | 'com
     componentMetadata: [string, SSRComponentMetadata][];
     clientDirectives: [string, string][];
 };
-export type AdapterCreateExports<T = any> = (manifest: SSRManifest, args?: T) => Record<string, any>;

package/dist/core/build/buildPipeline.js

@@ -2,17 +2,20 @@ import { getOutputDirectory, isServerLikeOutput } from "../../prerender/utils.js
 import { BEFORE_HYDRATION_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { Logger } from "../logger/core.js";
 import { Pipeline } from "../pipeline.js";
+import { routeIsFallback, routeIsRedirect } from "../redirects/helpers.js";
 import { createEnvironment } from "../render/index.js";
 import { createAssetLink } from "../render/ssr-element.js";
 import { ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugins/plugin-pages.js";
 import { RESOLVED_SPLIT_MODULE_ID } from "./plugins/plugin-ssr.js";
 import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
+import { i18nHasFallback } from "./util.js";
 class BuildPipeline extends Pipeline {
   #internals;
   #staticBuildOptions;
   #manifest;
   constructor(staticBuildOptions, internals, manifest) {
     const ssr = isServerLikeOutput(staticBuildOptions.settings.config);
+    const resolveCache = /* @__PURE__ */ new Map();
     super(
       createEnvironment({
         adapterName: manifest.adapterName,
@@ -22,14 +25,20 @@ class BuildPipeline extends Pipeline {
         clientDirectives: manifest.clientDirectives,
         compressHTML: manifest.compressHTML,
         async resolve(specifier) {
+          if (resolveCache.has(specifier)) {
+            return resolveCache.get(specifier);
+          }
           const hashedFilePath = manifest.entryModules[specifier];
           if (typeof hashedFilePath !== "string" || hashedFilePath === "") {
             if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
+              resolveCache.set(specifier, "");
               return "";
             }
             throw new Error(`Cannot find the built path for ${specifier}`);
           }
-          return createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
+          const assetLink = createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
+          resolveCache.set(specifier, assetLink);
+          return assetLink;
         },
         routeCache: staticBuildOptions.routeCache,
         site: manifest.site,
@@ -119,9 +128,13 @@ class BuildPipeline extends Pipeline {
         pages.set(pageData, filePath);
       }
     }
-    for (const [path, pageData] of this.#internals.pagesByComponent.entries()) {
-      if (pageData.route.type === "redirect") {
-        pages.set(pageData, path);
+    for (const [path, pageDataList] of this.#internals.pagesByComponents.entries()) {
+      for (const pageData of pageDataList) {
+        if (routeIsRedirect(pageData.route)) {
+          pages.set(pageData, path);
+        } else if (routeIsFallback(pageData.route) && (i18nHasFallback(this.getConfig()) || routeIsFallback(pageData.route) && pageData.route.route === "/")) {
+          pages.set(pageData, path);
+        }
       }
     }
     return pages;

package/dist/core/build/common.js

@@ -15,6 +15,7 @@ function getOutFolder(astroConfig, pathname, routeType) {
   switch (routeType) {
     case "endpoint":
       return new URL("." + appendForwardSlash(npath.dirname(pathname)), outRoot);
+    case "fallback":
     case "page":
     case "redirect":
       switch (astroConfig.build.format) {
@@ -36,6 +37,7 @@ function getOutFile(astroConfig, outFolder, pathname, routeType) {
     case "endpoint":
       return new URL(npath.basename(pathname), outFolder);
     case "page":
+    case "fallback":
     case "redirect":
       switch (astroConfig.build.format) {
         case "directory": {

package/dist/core/build/generate.js

@@ -17,11 +17,18 @@ import {
   removeLeadingForwardSlash,
   removeTrailingForwardSlash
 } from "../../core/path.js";
+import { createI18nMiddleware } from "../../i18n/middleware.js";
 import { runHookBuildGenerated } from "../../integrations/index.js";
 import { getOutputDirectory, isServerLikeOutput } from "../../prerender/utils.js";
 import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
-import { RedirectSinglePageBuiltModule, getRedirectLocationOrThrow } from "../redirects/index.js";
+import { sequence } from "../middleware/index.js";
+import { routeIsFallback } from "../redirects/helpers.js";
+import {
+  RedirectSinglePageBuiltModule,
+  getRedirectLocationOrThrow,
+  routeIsRedirect
+} from "../redirects/index.js";
 import { createRenderContext } from "../render/index.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
 import {
@@ -40,7 +47,7 @@ import {
   getPageDataByComponent,
   mergeInlineCss
 } from "./internal.js";
-import { getTimeStat } from "./util.js";
+import { getTimeStat, shouldAppendForwardSlash } from "./util.js";
 function createEntryURL(filePath, outFolder) {
   return new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
 }
@@ -58,6 +65,20 @@ async function getEntryForRedirectRoute(route, internals, outFolder) {
   }
   return RedirectSinglePageBuiltModule;
 }
+async function getEntryForFallbackRoute(route, internals, outFolder) {
+  if (route.type !== "fallback") {
+    throw new Error(`Expected a redirect route.`);
+  }
+  if (route.redirectRoute) {
+    const filePath = getEntryFilePathFromComponentPath(internals, route.redirectRoute.component);
+    if (filePath) {
+      const url = createEntryURL(filePath, outFolder);
+      const ssrEntryPage = await import(url.toString());
+      return ssrEntryPage;
+    }
+  }
+  return RedirectSinglePageBuiltModule;
+}
 function shouldSkipDraft(pageModule, settings) {
   return (
     // Drafts are disabled
@@ -131,16 +152,15 @@ ${bgGreen(black(` ${verb} static routes `))}`);
           await generatePage(pageData, ssrEntry, builtPaths, pipeline);
         }
       }
-      if (pageData.route.type === "redirect") {
-        const entry = await getEntryForRedirectRoute(pageData.route, internals, outFolder);
-        await generatePage(pageData, entry, builtPaths, pipeline);
-      }
     }
   } else {
     for (const [pageData, filePath] of pagesToGenerate) {
-      if (pageData.route.type === "redirect") {
+      if (routeIsRedirect(pageData.route)) {
         const entry = await getEntryForRedirectRoute(pageData.route, internals, outFolder);
         await generatePage(pageData, entry, builtPaths, pipeline);
+      } else if (routeIsFallback(pageData.route)) {
+        const entry = await getEntryForFallbackRoute(pageData.route, internals, outFolder);
+        await generatePage(pageData, entry, builtPaths, pipeline);
       } else {
         const ssrEntryURLPage = createEntryURL(filePath, outFolder);
         const entry = await import(ssrEntryURLPage.toString());
@@ -154,7 +174,7 @@ ${bgGreen(black(` ${verb} static routes `))}`);
   if (staticImageList.size) {
     logger.info(null, `
 ${bgGreen(black(` generating optimized images `))}`);
-    const totalCount = Array.from(staticImageList.values()).map((x) => x.size).reduce((a, b) => a + b, 0);
+    const totalCount = Array.from(staticImageList.values()).map((x) => x.transforms.size).reduce((a, b) => a + b, 0);
     const cpuCount = os.cpus().length;
     const assetsCreationEnvironment = await prepareAssetsGenerationEnv(pipeline, totalCount);
     const queue = new PQueue({ concurrency: cpuCount });
@@ -176,13 +196,26 @@ ${bgGreen(black(` generating optimized images `))}`);
 async function generatePage(pageData, ssrEntry, builtPaths, pipeline) {
   let timeStart = performance.now();
   const logger = pipeline.getLogger();
+  const config = pipeline.getConfig();
   const pageInfo = getPageDataByComponent(pipeline.getInternals(), pageData.route.component);
   const linkIds = [];
   const scripts = pageInfo?.hoistedScript ?? null;
   const styles = pageData.styles.sort(cssOrder).map(({ sheet }) => sheet).reduce(mergeInlineCss, []);
   const pageModulePromise = ssrEntry.page;
   const onRequest = ssrEntry.onRequest;
-  if (onRequest) {
+  const i18nMiddleware = createI18nMiddleware(
+    pipeline.getManifest().i18n,
+    pipeline.getManifest().base
+  );
+  if (config.experimental.i18n && i18nMiddleware) {
+    if (onRequest) {
+      pipeline.setMiddlewareFunction(
+        sequence(i18nMiddleware, onRequest)
+      );
+    } else {
+      pipeline.setMiddlewareFunction(i18nMiddleware);
+    }
+  } else if (onRequest) {
     pipeline.setMiddlewareFunction(onRequest);
   }
   if (!pageModulePromise) {
@@ -206,7 +239,7 @@ async function generatePage(pageData, ssrEntry, builtPaths, pipeline) {
     styles,
     mod: pageModule
   };
-  const icon = pageData.route.type === "page" || pageData.route.type === "redirect" ? green("\u25B6") : magenta("\u03BB");
+  const icon = pageData.route.type === "page" || pageData.route.type === "redirect" || pageData.route.type === "fallback" ? green("\u25B6") : magenta("\u03BB");
   if (isRelativePath(pageData.route.component)) {
     logger.info(null, `${icon} ${pageData.route.route}`);
   } else {
@@ -297,22 +330,6 @@ function getInvalidRouteSegmentError(e, route, staticPath) {
     hint
   });
 }
-function shouldAppendForwardSlash(trailingSlash, buildFormat) {
-  switch (trailingSlash) {
-    case "always":
-      return true;
-    case "never":
-      return false;
-    case "ignore": {
-      switch (buildFormat) {
-        case "directory":
-          return true;
-        case "file":
-          return false;
-      }
-    }
-  }
-}
 function addPageName(pathname, opts) {
   const trailingSlash = opts.settings.config.trailingSlash;
   const buildFormat = opts.settings.config.build.format;
@@ -375,21 +392,24 @@ async function generatePath(pathname, gopts, pipeline) {
     pipeline.getConfig().build.format,
     pageData.route.type
   );
+  const request = createRequest({
+    url,
+    headers: new Headers(),
+    logger: pipeline.getLogger(),
+    ssr
+  });
+  const i18n = pipeline.getConfig().experimental.i18n;
   const renderContext = await createRenderContext({
     pathname,
-    request: createRequest({
-      url,
-      headers: new Headers(),
-      logger: pipeline.getLogger(),
-      ssr
-    }),
+    request,
     componentMetadata: manifest.componentMetadata,
     scripts,
     styles,
     links,
     route: pageData.route,
     env: pipeline.getEnvironment(),
-    mod
+    mod,
+    locales: i18n ? i18n.locales : void 0
   });
   let body;
   let encoding;
@@ -438,6 +458,15 @@ async function generatePath(pathname, gopts, pipeline) {
   await fs.promises.writeFile(outFile, body, encoding);
 }
 function createBuildManifest(settings, internals, renderers) {
+  let i18nManifest = void 0;
+  if (settings.config.experimental.i18n) {
+    i18nManifest = {
+      fallback: settings.config.experimental.i18n.fallback,
+      routingStrategy: settings.config.experimental.i18n.routingStrategy,
+      defaultLocale: settings.config.experimental.i18n.defaultLocale,
+      locales: settings.config.experimental.i18n.locales
+    };
+  }
   return {
     assets: /* @__PURE__ */ new Set(),
     entryModules: Object.fromEntries(internals.entrySpecifierToBundleMap.entries()),
@@ -449,7 +478,8 @@ function createBuildManifest(settings, internals, renderers) {
     base: settings.config.base,
     assetsPrefix: settings.config.build.assetsPrefix,
     site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
-    componentMetadata: internals.componentMetadata
+    componentMetadata: internals.componentMetadata,
+    i18n: i18nManifest
   };
 }
 export {

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

@@ -1,13 +1,5 @@
 import type { AstroInlineConfig } from '../../@types/astro.js';
 export interface BuildOptions {
-    /**
-     * Teardown the compiler WASM instance after build. This can improve performance when
-     * building once, but may cause a performance hit if building multiple times in a row.
-     *
-     * @internal only used for testing
-     * @default true
-     */
-    teardownCompiler?: boolean;
 }
 /**
  * Builds your site for deployment. By default, this will generate static files and place them in a dist/ directory.

package/dist/core/build/index.js

@@ -23,11 +23,18 @@ import { createRouteManifest } from "../routing/index.js";
 import { collectPagesData } from "./page-data.js";
 import { staticBuild, viteBuild } from "./static-build.js";
 import { getTimeStat } from "./util.js";
-async function build(inlineConfig, options) {
+async function build(inlineConfig, options = {}) {
   applyPolyfill();
   const logger = createNodeLogger(inlineConfig);
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig, "build");
   telemetry.record(eventCliSession("build", userConfig));
+  if (astroConfig.experimental.contentCollectionCache && options.force) {
+    const contentCacheDir = new URL("./content/", astroConfig.cacheDir);
+    if (fs.existsSync(contentCacheDir)) {
+      logger.warn("content", "clearing cache");
+      await fs.promises.rm(contentCacheDir, { force: true, recursive: true });
+    }
+  }
   const settings = await createSettings(astroConfig, fileURLToPath(astroConfig.root));
   const builder = new AstroBuilder(settings, {
     ...options,
@@ -138,7 +145,7 @@ class AstroBuilder {
     await runHookBuildDone({
       config: this.settings.config,
       pages: pageNames,
-      routes: Object.values(allPages).map((pd) => pd.route),
+      routes: Object.values(allPages).flat().map((pageData) => pageData.route),
       logging: this.logger
     });
     if (this.logger.level && levels[this.logger.level()] <= levels["info"]) {