astro 7.1.4 → 7.1.6

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "7.1.4";
+  version = "7.1.6";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/container/index.js

@@ -65,8 +65,7 @@ function createManifest(manifest, renderers, middleware) {
       debugInfoOutput: "",
       placement: void 0
     },
-    logLevel: "silent",
-    loggerConfig: manifest?.loggerConfig ?? void 0
+    logLevel: "silent"
   };
 }
 class experimental_AstroContainer {

package/dist/content/consts.d.ts

@@ -28,3 +28,7 @@ export declare const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
 export declare const COLLECTIONS_DIR = "collections/";
 export declare const CONTENT_LAYER_TYPE = "content_layer";
 export declare const LIVE_CONTENT_TYPE = "live";
+export declare const DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX = "astro:data-layer-content-chunk:";
+export declare const RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX = "\0astro:data-layer-content-chunk:";
+export declare const RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX = ".mjs";
+export declare const DATA_STORE_CHUNK_FILE_NAME_PATTERN: RegExp;

package/dist/content/consts.js

@@ -35,6 +35,10 @@ const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
 const COLLECTIONS_DIR = "collections/";
 const CONTENT_LAYER_TYPE = "content_layer";
 const LIVE_CONTENT_TYPE = "live";
+const DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX = `${DATA_STORE_VIRTUAL_ID}-chunk:`;
+const RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX = `\0${DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX}`;
+const RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX = ".mjs";
+const DATA_STORE_CHUNK_FILE_NAME_PATTERN = /^[a-f0-9]{16}\.txt$/;
 export {
   ASSET_IMPORTS_FILE,
   ASSET_IMPORTS_RESOLVED_STUB_ID,
@@ -49,6 +53,8 @@ export {
   CONTENT_RENDER_FLAG,
   CONTENT_TYPES_FILE,
   DATA_FLAG,
+  DATA_STORE_CHUNK_FILE_NAME_PATTERN,
+  DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX,
   DATA_STORE_DIR,
   DATA_STORE_FILE,
   DATA_STORE_MANIFEST_FILE,
@@ -62,6 +68,8 @@ export {
   MODULES_MJS_VIRTUAL_ID,
   PROPAGATED_ASSET_FLAG,
   PROPAGATED_ASSET_QUERY_PARAM,
+  RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX,
+  RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX,
   RESOLVED_DATA_STORE_VIRTUAL_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
   STYLES_PLACEHOLDER,

package/dist/content/content-layer.js

@@ -196,7 +196,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.1.4") {
+    if (previousAstroVersion && previousAstroVersion !== "7.1.6") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -204,8 +204,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.1.4") {
-      this.#store.metaStore().set("astro-version", "7.1.4");
+    if ("7.1.6") {
+      this.#store.metaStore().set("astro-version", "7.1.6");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/data-store-writer.d.ts

@@ -62,6 +62,6 @@ export declare class FileWriter implements DataStoreWriter {
  */
 export declare class ChunkedWriter implements DataStoreWriter {
     #private;
-    constructor(dir: URL);
+    constructor(dir: URL, chunkSize: number);
     write(collections: Map<string, Map<string, any>>): Promise<void>;
 }

package/dist/content/data-store-writer.js

@@ -3,7 +3,6 @@ import * as devalue from "devalue";
 import xxhash, {} from "xxhash-wasm";
 import { emptyDir } from "../core/fs/index.js";
 import { DATA_STORE_MANIFEST_FILE } from "./consts.js";
-const CHUNK_SIZE_LIMIT = 20 * 1024 * 1024;
 function sortCollections(collections) {
   return new Map(
     [...collections.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, collection]) => [
@@ -57,10 +56,12 @@ class FileWriter {
 class ChunkedWriter {
   #dir;
   #manifestFile;
+  #chunkSize;
   #hasher;
-  constructor(dir) {
+  constructor(dir, chunkSize) {
     this.#dir = dir;
     this.#manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dir);
+    this.#chunkSize = chunkSize;
   }
   async write(collections) {
     if (!this.#hasher) {
@@ -72,7 +73,7 @@ class ChunkedWriter {
     for (const [collectionName, entries] of sortCollections(collections)) {
       const stringified = devalue.stringify(entries);
       const parts = [];
-      for (const part of chunkString(stringified, CHUNK_SIZE_LIMIT)) {
+      for (const part of chunkString(stringified, this.#chunkSize)) {
         const fileName = `${h64ToString(part)}.txt`;
         await writeFileAtomic(new URL(`./${fileName}`, this.#dir), part);
         parts.push(fileName);

package/dist/content/data-store.d.ts

@@ -51,9 +51,9 @@ export declare class ImmutableDataStore {
      * names have already been swapped for their contents.
      *
      * Each collection maps to a list of parts. A part is either a raw string
-     * (when the store is loaded from disk) or an ESM namespace from a `?raw`
-     * import (`{ default: string }`, when emitted into the virtual module at
-     * runtime). A collection's parts are concatenated back into the exact
+     * (when the store is loaded from disk) or an ESM namespace from a virtual
+     * chunk import (`{ default: string }`, when emitted at runtime). A collection's
+     * parts are concatenated back into the exact
      * serialized string, then parsed with devalue. This is the inverse of
      * {@link import('./data-store-writer.js').ChunkedWriter} and stays free of
      * Node built-ins so it can run at runtime.

package/dist/content/data-store.js

@@ -38,9 +38,9 @@ class ImmutableDataStore {
    * names have already been swapped for their contents.
    *
    * Each collection maps to a list of parts. A part is either a raw string
-   * (when the store is loaded from disk) or an ESM namespace from a `?raw`
-   * import (`{ default: string }`, when emitted into the virtual module at
-   * runtime). A collection's parts are concatenated back into the exact
+   * (when the store is loaded from disk) or an ESM namespace from a virtual
+   * chunk import (`{ default: string }`, when emitted at runtime). A collection's
+   * parts are concatenated back into the exact
    * serialized string, then parsed with devalue. This is the inverse of
    * {@link import('./data-store-writer.js').ChunkedWriter} and stays free of
    * Node built-ins so it can run at runtime.

package/dist/content/mutable-data-store.d.ts

@@ -36,13 +36,13 @@ export declare class MutableDataStore extends ImmutableDataStore {
     static fromString(data: string): Promise<MutableDataStore>;
     static fromFile(filePath: string | URL): Promise<MutableDataStore>;
     /**
-     * Loads a MutableDataStore from a chunked store directory (experimental
-     * `collectionStorage: 'chunked'`), reading the manifest and its referenced parts.
+     * Loads a MutableDataStore from a chunked store directory, reading the manifest
+     * and its referenced parts.
      * If the directory has no manifest yet (fresh build) it starts empty. If the
      * manifest exists but can't be read (corrupt cache), it warns and starts
      * empty so loaders rebuild it, rather than failing the sync.
      */
-    static fromDir(dirPath: URL): Promise<MutableDataStore>;
+    static fromDir(dirPath: URL, chunkSize: number): Promise<MutableDataStore>;
 }
 export interface DataStore {
     get: <TData extends Record<string, unknown> = Record<string, unknown>>(key: string) => DataEntry<TData> | undefined;

package/dist/content/mutable-data-store.js

@@ -412,13 +412,13 @@ ${lines.join(",\n")}]);
     return store;
   }
   /**
-   * Loads a MutableDataStore from a chunked store directory (experimental
-   * `collectionStorage: 'chunked'`), reading the manifest and its referenced parts.
+   * Loads a MutableDataStore from a chunked store directory, reading the manifest
+   * and its referenced parts.
    * If the directory has no manifest yet (fresh build) it starts empty. If the
    * manifest exists but can't be read (corrupt cache), it warns and starts
    * empty so loaders rebuild it, rather than failing the sync.
    */
-  static async fromDir(dirPath) {
+  static async fromDir(dirPath, chunkSize) {
     const manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dirPath);
     if (existsSync(manifestFile)) {
       try {
@@ -434,7 +434,7 @@ ${lines.join(",\n")}]);
         }
         const map = ImmutableDataStore.manifestToMap(expanded);
         const store2 = await MutableDataStore.fromMap(map);
-        store2.#writer = new ChunkedWriter(dirPath);
+        store2.#writer = new ChunkedWriter(dirPath, chunkSize);
         return store2;
       } catch (err) {
         console.warn(
@@ -445,7 +445,7 @@ ${lines.join(",\n")}]);
     }
     await fs.mkdir(dirPath, { recursive: true });
     const store = new MutableDataStore();
-    store.#writer = new ChunkedWriter(dirPath);
+    store.#writer = new ChunkedWriter(dirPath, chunkSize);
     return store;
   }
 }

package/dist/content/paths.d.ts

@@ -5,9 +5,10 @@ import type { AstroSettings } from '../types/astro.js';
  * In production, it's in the cache directory so that it's preserved between builds.
  */
 export declare function getDataStoreFile(settings: AstroSettings, isDev: boolean): URL;
+export declare function getDataStoreChunkSize(settings: AstroSettings): number | undefined;
 /**
  * Get the path to the data store directory, used when the store is split across
- * multiple files (experimental `collectionStorage: 'chunked'`).
+ * multiple files.
  * During development, this is in the `.astro` directory so that the Vite watcher can see it.
  * In production, it's in the cache directory so that it's preserved between builds.
  */

package/dist/content/paths.js

@@ -2,10 +2,21 @@ import { DATA_STORE_DIR, DATA_STORE_FILE } from "./consts.js";
 function getDataStoreFile(settings, isDev) {
   return new URL(DATA_STORE_FILE, isDev ? settings.dotAstroDir : settings.config.cacheDir);
 }
+function getDataStoreChunkSize(settings) {
+  const storage = settings.config.experimental.collectionStorage;
+  if (storage === void 0 || storage === "single-file") {
+    return void 0;
+  }
+  if (storage === "chunked") {
+    return 20 * 1024 * 1024;
+  }
+  return storage.chunkSize;
+}
 function getDataStoreDir(settings, isDev) {
   return new URL(DATA_STORE_DIR, isDev ? settings.dotAstroDir : settings.config.cacheDir);
 }
 export {
+  getDataStoreChunkSize,
   getDataStoreDir,
   getDataStoreFile
 };

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

@@ -13,16 +13,20 @@ 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) {
@@ -81,11 +85,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 +112,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 +127,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);
@@ -154,10 +165,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({
@@ -179,18 +211,12 @@ function astroContentVirtualModPlugin({
             return { code: "export default new Map()" };
           }
           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: "" } };

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

@@ -12,7 +12,6 @@ import type { BaseSessionConfig, SessionDriverFactory } from '../session/types.j
 import type { DevToolbarPlacement } from '../../types/public/toolbar.js';
 import type { MiddlewareMode } from '../../types/public/integrations.js';
 import type { BaseApp } from './base.js';
-import type { LoggerHandlerConfig } from '../logger/config.js';
 type ComponentPath = string;
 export type StylesheetAsset = {
     type: 'inline';
@@ -138,7 +137,6 @@ export type SSRManifest = {
     };
     internalFetchHeaders?: Record<string, string>;
     logLevel: AstroLoggerLevel;
-    loggerConfig: LoggerHandlerConfig | undefined;
 };
 export type SSRActions = {
     server: Record<string, ActionClient<any, any, any>>;

package/dist/core/base-pipeline.js

@@ -11,7 +11,6 @@ import { createDefaultRoutes } from "./routing/default.js";
 import { ensure404Route } from "./routing/astro-designed-error-pages.js";
 import { Router } from "./routing/router.js";
 import { FORBIDDEN_PATH_KEYS } from "@astrojs/internal-helpers/object";
-import { loadLoggerDestination } from "./logger/load.js";
 const PipelineFeatures = {
   redirects: 1 << 0,
   sessions: 1 << 1,
@@ -171,9 +170,10 @@ class Pipeline {
       return this.logger;
     }
     this.resolvedLogger = true;
-    if (this.manifest.loggerConfig) {
+    const destination = (await this.manifest.logger?.())?.default;
+    if (destination) {
       this.logger = new AstroLogger({
-        destination: await loadLoggerDestination(this.manifest.loggerConfig),
+        destination,
         level: this.manifest.logLevel
       });
     }
@@ -231,6 +231,12 @@ class Pipeline {
       );
     }
     for (const key of pathKeys) {
+      if (typeof server === "function") {
+        throw new AstroError({
+          ...ActionNotFoundError,
+          message: ActionNotFoundError.message(pathKeys.join("."))
+        });
+      }
       if (FORBIDDEN_PATH_KEYS.has(key)) {
         throw new AstroError({
           ...ActionNotFoundError,

package/dist/core/build/generate.js

@@ -69,7 +69,10 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
     const hasI18nDomains = ssr && options.settings.config.i18n?.domains && Object.keys(options.settings.config.i18n.domains).length > 0;
     const { config } = options.settings;
     const builtPaths = /* @__PURE__ */ new Set();
-    const filteredPaths = pathsWithRoutes.filter(({ pathname, route }) => {
+    const filteredPaths = [];
+    const fallbackPaths = [];
+    for (const pathWithRoute of pathsWithRoutes) {
+      const { pathname, route } = pathWithRoute;
       if (hasI18nDomains && route.prerender) {
         throw new AstroError({
           ...AstroErrorData.NoPrerenderedRoutesWithDomains,
@@ -79,44 +82,44 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
       const normalized = removeTrailingForwardSlash(pathname);
       if (!builtPaths.has(normalized)) {
         builtPaths.add(normalized);
-        return true;
-      }
-      const matchedRoute = matchRoute(decodeURI(pathname), options.routesList);
-      if (!matchedRoute) {
-        return false;
-      }
-      if (matchedRoute === route) {
-        return true;
-      }
-      if (config.prerenderConflictBehavior === "error") {
-        throw new AstroError({
-          ...AstroErrorData.PrerenderRouteConflict,
-          message: AstroErrorData.PrerenderRouteConflict.message(
-            matchedRoute.route,
-            route.route,
-            normalized
-          ),
-          hint: AstroErrorData.PrerenderRouteConflict.hint(matchedRoute.route, route.route)
-        });
-      } else if (config.prerenderConflictBehavior === "warn") {
-        const msg = AstroErrorData.PrerenderRouteConflict.message(
-          matchedRoute.route,
-          route.route,
-          normalized
-        );
-        logger.warn("build", msg);
+      } else {
+        const matchedRoute = matchRoute(decodeURI(pathname), options.routesList);
+        if (!matchedRoute) {
+          continue;
+        }
+        if (matchedRoute !== route) {
+          if (config.prerenderConflictBehavior === "error") {
+            throw new AstroError({
+              ...AstroErrorData.PrerenderRouteConflict,
+              message: AstroErrorData.PrerenderRouteConflict.message(
+                matchedRoute.route,
+                route.route,
+                normalized
+              ),
+              hint: AstroErrorData.PrerenderRouteConflict.hint(matchedRoute.route, route.route)
+            });
+          } else if (config.prerenderConflictBehavior === "warn") {
+            const msg = AstroErrorData.PrerenderRouteConflict.message(
+              matchedRoute.route,
+              route.route,
+              normalized
+            );
+            logger.warn("build", msg);
+          }
+          continue;
+        }
       }
-      return false;
-    });
+      const paths = route.type === "fallback" ? fallbackPaths : filteredPaths;
+      paths.push(pathWithRoute);
+    }
+    const generationPhases = [filteredPaths, fallbackPaths];
     if (config.build.concurrency > 1) {
       const limit = PLimit(config.build.concurrency);
       const BATCH_SIZE = 1e5;
-      for (let i = 0; i < filteredPaths.length; i += BATCH_SIZE) {
-        const batch = filteredPaths.slice(i, i + BATCH_SIZE);
-        const promises = [];
-        for (const { pathname, route } of batch) {
-          promises.push(
-            limit(
+      for (const paths of generationPhases) {
+        for (let i = 0; i < paths.length; i += BATCH_SIZE) {
+          const promises = paths.slice(i, i + BATCH_SIZE).map(
+            ({ pathname, route }) => limit(
               () => generatePathWithPrerenderer(
                 prerenderer,
                 pathname,
@@ -127,27 +130,31 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
               )
             )
           );
+          await Promise.all(promises);
         }
-        await Promise.all(promises);
       }
     } else {
-      for (const { pathname, route } of filteredPaths) {
-        await generatePathWithPrerenderer(
-          prerenderer,
-          pathname,
-          route,
-          options,
-          routeToHeaders,
-          logger
-        );
+      for (const paths of generationPhases) {
+        for (const { pathname, route } of paths) {
+          await generatePathWithPrerenderer(
+            prerenderer,
+            pathname,
+            route,
+            options,
+            routeToHeaders,
+            logger
+          );
+        }
       }
     }
-    for (const { route: generatedRoute } of filteredPaths) {
-      if (generatedRoute.distURL && generatedRoute.distURL.length > 0) {
-        for (const pageData of Object.values(options.allPages)) {
-          if (pageData.route.route === generatedRoute.route && pageData.route.component === generatedRoute.component) {
-            pageData.route.distURL = generatedRoute.distURL;
-            break;
+    for (const paths of generationPhases) {
+      for (const { route: generatedRoute } of paths) {
+        if (generatedRoute.distURL && generatedRoute.distURL.length > 0) {
+          for (const pageData of Object.values(options.allPages)) {
+            if (pageData.route.route === generatedRoute.route && pageData.route.component === generatedRoute.component) {
+              pageData.route.distURL = generatedRoute.distURL;
+              break;
+            }
           }
         }
       }

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

@@ -236,10 +236,6 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
     }
   }
   const middlewareMode = resolveMiddlewareMode(opts.settings.adapter?.adapterFeatures);
-  let loggerConfig = void 0;
-  if (settings.config.logger) {
-    loggerConfig = settings.config.logger;
-  }
   return {
     rootDir: opts.settings.config.root.toString(),
     cacheDir: opts.settings.config.cacheDir.toString(),
@@ -288,8 +284,7 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
     },
     internalFetchHeaders,
     logLevel: settings.logLevel,
-    shouldInjectCspMetaTags: shouldTrackCspHashes(settings.config.security.csp),
-    loggerConfig
+    shouldInjectCspMetaTags: shouldTrackCspHashes(settings.config.security.csp)
   };
 }
 export {

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

@@ -488,10 +488,10 @@ export declare const AstroConfigSchema: z.ZodObject<{
             name: z.ZodString;
             optimize: z.ZodCustom<(contents: string) => string | Promise<string>, (contents: string) => string | Promise<string>>;
         }, z.core.$strip>>;
-        collectionStorage: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            "single-file": "single-file";
-            chunked: "chunked";
-        }>>>;
+        collectionStorage: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"single-file">, z.ZodLiteral<"chunked">, z.ZodObject<{
+            type: z.ZodLiteral<"chunked">;
+            chunkSize: z.ZodNumber;
+        }, z.core.$strict>]>>>;
     }, z.core.$strict>>;
     legacy: z.ZodPrefault<z.ZodObject<{
         collectionsBackwardsCompat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;

package/dist/core/config/schemas/base.js

@@ -277,7 +277,14 @@ const AstroConfigSchema = z.object({
     contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
     chromeDevtoolsWorkspace: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.chromeDevtoolsWorkspace),
     svgOptimizer: SvgOptimizerSchema.optional(),
-    collectionStorage: z.enum(["single-file", "chunked"]).optional().default(ASTRO_CONFIG_DEFAULTS.experimental.collectionStorage)
+    collectionStorage: z.union([
+      z.literal("single-file"),
+      z.literal("chunked"),
+      z.strictObject({
+        type: z.literal("chunked"),
+        chunkSize: z.number().int().positive()
+      })
+    ]).optional().default(ASTRO_CONFIG_DEFAULTS.experimental.collectionStorage)
   }).prefault({}),
   legacy: z.object({
     collectionsBackwardsCompat: z.boolean().optional().default(false)

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

@@ -440,10 +440,10 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             name: z.ZodString;
             optimize: z.ZodCustom<(contents: string) => string | Promise<string>, (contents: string) => string | Promise<string>>;
         }, z.core.$strip>>;
-        collectionStorage: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            "single-file": "single-file";
-            chunked: "chunked";
-        }>>>;
+        collectionStorage: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"single-file">, z.ZodLiteral<"chunked">, z.ZodObject<{
+            type: z.ZodLiteral<"chunked">;
+            chunkSize: z.ZodNumber;
+        }, z.core.$strict>]>>>;
     }, z.core.$strict>>;
     legacy: z.ZodPrefault<z.ZodObject<{
         collectionsBackwardsCompat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -630,7 +630,10 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
-        collectionStorage: "single-file" | "chunked";
+        collectionStorage: "single-file" | "chunked" | {
+            type: "chunked";
+            chunkSize: number;
+        };
         svgOptimizer?: {
             name: string;
             optimize: (contents: string) => string | Promise<string>;
@@ -893,7 +896,10 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
-        collectionStorage: "single-file" | "chunked";
+        collectionStorage: "single-file" | "chunked" | {
+            type: "chunked";
+            chunkSize: number;
+        };
         svgOptimizer?: {
             name: string;
             optimize: (contents: string) => string | Promise<string>;

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.1.4";
+const ASTRO_VERSION = "7.1.6";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";