astro 7.1.4 → 7.1.6

package/dist/core/create-vite.js

@@ -48,6 +48,7 @@ import { ServerIslandsState } from "./server-islands/shared-state.js";
 import { vitePluginServerIslands } from "./server-islands/vite-plugin-server-islands.js";
 import { vitePluginCacheProvider } from "./cache/vite-plugin.js";
 import { vitePluginSessionDriver } from "./session/vite-plugin.js";
+import { vitePluginLogger } from "./logger/vite-plugin.js";
 import { isObject } from "./util-runtime.js";
 import { vitePluginEnvironment } from "../vite-plugin-environment/index.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "./constants.js";
@@ -180,6 +181,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       vitePluginServerIslands({ settings, logger, serverIslandsState }),
       vitePluginSessionDriver({ settings }),
       vitePluginCacheProvider({ settings }),
+      vitePluginLogger({ settings }),
       astroContainer(),
       astroHmrReloadPlugin(),
       vitePluginChromedevtools({ settings }),

package/dist/core/dev/dev.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import { performance } from "node:perf_hooks";
 import colors from "piccolore";
 import { gt, major, minor, patch } from "semver";
-import { getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
+import { getDataStoreChunkSize, getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
 import { globalContentLayer } from "../../content/instance.js";
 import { attachContentServerListeners } from "../../content/index.js";
 import { MutableDataStore } from "../../content/mutable-data-store.js";
@@ -26,7 +26,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "7.1.4";
+  const currentVersion = "7.1.6";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -56,9 +56,10 @@ async function dev(inlineConfig) {
   }
   let store;
   try {
-    if (restart.container.settings.config.experimental.collectionStorage === "chunked") {
+    const chunkSize = getDataStoreChunkSize(restart.container.settings);
+    if (chunkSize !== void 0) {
       const dataStoreDir = getDataStoreDir(restart.container.settings, true);
-      store = await MutableDataStore.fromDir(dataStoreDir);
+      store = await MutableDataStore.fromDir(dataStoreDir, chunkSize);
     } else {
       const dataStoreFile = getDataStoreFile(restart.container.settings, true);
       store = await MutableDataStore.fromFile(dataStoreFile);

package/dist/core/errors/default-handler.d.ts

@@ -1,6 +1,6 @@
 import type { BaseApp, RenderErrorOptions } from '../app/base.js';
 import type { Pipeline } from '../base-pipeline.js';
-import type { ErrorHandler } from './handler.js';
+import { type ErrorHandler } from './handler.js';
 /**
  * The default error handler used in production SSR. Attempts to render the
  * matching error route (404.astro / 500.astro), falling back to a plain

package/dist/core/errors/default-handler.js

@@ -9,6 +9,7 @@ import { provideSession } from "../session/handler.js";
 import { validateHost } from "../app/validate-headers.js";
 import { getErrorRoutePath } from "../../i18n/error-routes.js";
 import { getOutputFilename } from "../output-filename.js";
+import { rewroteToEmptyErrorResponse } from "./handler.js";
 class DefaultErrorHandler {
   #app;
   #astroMiddleware;
@@ -82,6 +83,21 @@ class DefaultErrorHandler {
           errorState,
           this.#pagesHandler.handle.bind(this.#pagesHandler)
         );
+        if (rewroteToEmptyErrorResponse(
+          skipMiddleware,
+          errorRouteData,
+          errorState.routeData,
+          response2
+        )) {
+          return this.renderError(request, {
+            ...resolvedRenderOptions,
+            status,
+            error,
+            response: originalResponse,
+            skipMiddleware: true,
+            pathname: resolvedPathname
+          });
+        }
         const newResponse = mergeResponses(response2, originalResponse);
         prepareResponse(newResponse, resolvedRenderOptions);
         return newResponse;

package/dist/core/errors/dev-handler.d.ts

@@ -1,6 +1,6 @@
 import type { BaseApp, RenderErrorOptions } from '../app/base.js';
 import type { Pipeline } from '../base-pipeline.js';
-import type { ErrorHandler } from './handler.js';
+import { type ErrorHandler } from './handler.js';
 export interface DevErrorHandlerOptions {
     /**
      * Whether to inject CSP meta tags into the rendered error page response.

package/dist/core/errors/dev-handler.js

@@ -4,6 +4,7 @@ import { PagesHandler } from "../pages/handler.js";
 import { getCustom404Route, getCustom500Route } from "../routing/helpers.js";
 import { isAstroError } from "./index.js";
 import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "./errors-data.js";
+import { rewroteToEmptyErrorResponse } from "./handler.js";
 class DevErrorHandler {
   #app;
   #shouldInjectCspMetaTags;
@@ -46,6 +47,15 @@ class DevErrorHandler {
           errorState,
           this.#pagesHandler.handle.bind(this.#pagesHandler)
         );
+        if (rewroteToEmptyErrorResponse(skipMiddleware, routeData, errorState.routeData, response)) {
+          return this.renderError(request, {
+            ...resolvedRenderOptions,
+            status,
+            error,
+            skipMiddleware: true,
+            pathname: resolvedPathname
+          });
+        }
         if (error) {
           app.logger.error("router", error.stack || error.message);
         }

package/dist/core/errors/handler.d.ts

@@ -1,4 +1,5 @@
 import type { RenderErrorOptions } from '../app/base.js';
+import type { RouteData } from '../../types/public/index.js';
 /**
  * A strategy for rendering error responses (404, 500, etc.). Each execution
  * environment (prod SSR, build/prerender, dev server) supplies its own
@@ -7,3 +8,16 @@ import type { RenderErrorOptions } from '../app/base.js';
 export interface ErrorHandler {
     renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
 }
+/**
+ * Whether a middleware rewrite (`ctx.rewrite()` / `next(payload)`) issued while
+ * rendering the error page dead-ended in another empty reroutable (404/500)
+ * response. The rewrite swaps the state's routeData away from the error route,
+ * so returning that render as-is would produce a blank page; the error handler
+ * should instead retry rendering the error page without middleware.
+ *
+ * @param skipMiddleware Whether middleware was already skipped for this render.
+ * @param errorRouteData The error route matched before middleware ran.
+ * @param renderedRouteData The route data on the state after middleware ran.
+ * @param response The response produced by the middleware-driven render.
+ */
+export declare function rewroteToEmptyErrorResponse(skipMiddleware: boolean, errorRouteData: RouteData, renderedRouteData: RouteData | undefined, response: Response): boolean;

package/dist/core/errors/handler.js

@@ -0,0 +1,7 @@
+import { REROUTABLE_STATUS_CODES } from "../constants.js";
+function rewroteToEmptyErrorResponse(skipMiddleware, errorRouteData, renderedRouteData, response) {
+  return skipMiddleware === false && renderedRouteData !== errorRouteData && response.body === null && REROUTABLE_STATUS_CODES.includes(response.status);
+}
+export {
+  rewroteToEmptyErrorResponse
+};

package/dist/core/logger/load.d.ts

@@ -1,6 +1,10 @@
 import { AstroLogger, type AstroLoggerDestination } from './core.js';
 import type { LoggerHandlerConfig } from './config.js';
 import type { AstroConfig, AstroInlineConfig } from '../../types/public/index.js';
+/**
+ * Loads a logger destination in a Node context, i.e. outside of a built server bundle.
+ * Inside the bundle, the destination comes from the `virtual:astro:logger` module instead.
+ */
 export declare function loadLoggerDestination(config: LoggerHandlerConfig): Promise<AstroLoggerDestination>;
 /**
  * It attempts to load a logger from the entrypoint.

package/dist/core/logger/load.js

@@ -1,64 +1,38 @@
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
 import { AstroLogger } from "./core.js";
 import { AstroError } from "../errors/index.js";
 import { UnableToLoadLogger } from "../errors/errors-data.js";
-import { default as nodeLoggerCreator, createNodeLoggerFromFlags } from "./impls/node.js";
-import { default as consoleLoggerCreator } from "./impls/console.js";
-import { default as jsonLoggerCreator } from "./impls/json.js";
-import { default as composeLoggerCreator } from "./impls/compose.js";
-function normalizeEntrypoint(entrypoint) {
-  return entrypoint instanceof URL ? entrypoint.href : entrypoint;
+import { createNodeLoggerFromFlags } from "./impls/node.js";
+import {
+  COMPOSE_LOGGER_ENTRYPOINT,
+  normalizeLoggerConfig
+} from "./utils.js";
+async function createDestination(config) {
+  const specifier = isAbsolute(config.entrypoint) ? pathToFileURL(config.entrypoint).href : config.entrypoint;
+  const logger = await import(
+    /* @vite-ignore */
+    specifier
+  );
+  if (config.entrypoint === COMPOSE_LOGGER_ENTRYPOINT) {
+    return logger.default(await Promise.all((config.loggers ?? []).map(createDestination)));
+  }
+  return logger.default(config.config);
 }
 async function loadLoggerDestination(config) {
-  let cause = void 0;
-  const entrypoint = normalizeEntrypoint(config.entrypoint);
+  const normalized = normalizeLoggerConfig(config);
   try {
-    switch (config.entrypoint) {
-      case "astro/logger/node": {
-        return nodeLoggerCreator(config.config);
-      }
-      case "astro/logger/console": {
-        return consoleLoggerCreator(config.config);
-      }
-      case "astro/logger/json": {
-        return jsonLoggerCreator(config.config);
-      }
-      case "astro/logger/compose": {
-        let destinations = [];
-        if (config.config?.loggers) {
-          const loggers = config.config?.loggers;
-          destinations = await Promise.all(
-            loggers.map(async (loggerConfig) => {
-              const logger = await import(
-                /* @vite-ignore */
-                normalizeEntrypoint(loggerConfig.entrypoint)
-              );
-              return logger.default(loggerConfig.config);
-            })
-          );
-        }
-        return composeLoggerCreator(destinations);
-      }
-      default: {
-        const logger = await import(
-          /* @vite-ignore */
-          entrypoint
-        );
-        return logger.default(config.config);
-      }
-    }
+    return await createDestination(normalized);
   } catch (e) {
+    const error = new AstroError({
+      ...UnableToLoadLogger,
+      message: UnableToLoadLogger.message(normalized.entrypoint)
+    });
     if (e instanceof Error) {
-      cause = e;
+      error.cause = e;
     }
+    throw error;
   }
-  const error = new AstroError({
-    ...UnableToLoadLogger,
-    message: UnableToLoadLogger.message(entrypoint)
-  });
-  if (cause) {
-    error.cause = cause;
-  }
-  throw error;
 }
 async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
   if (inlineAstroConfig._logger) return inlineAstroConfig._logger;

package/dist/core/logger/utils.d.ts

@@ -0,0 +1,21 @@
+import type { LoggerHandlerConfig } from './config.js';
+export declare const COMPOSE_LOGGER_ENTRYPOINT = "astro/logger/compose";
+export interface NormalizedLoggerConfig {
+    /** An absolute file path or a package specifier */
+    entrypoint: string;
+    /** Serializable options passed to the handler factory */
+    config?: Record<string, any> | undefined;
+    /** The composed handlers. Only set for `astro/logger/compose` */
+    loggers?: NormalizedLoggerConfig[];
+}
+/**
+ * Normalizes a user-provided logger config by turning its `entrypoint` into a string that
+ * can be resolved as-is, either by Vite (see `vitePluginLogger`) or by Node
+ * (see `loadLoggerDestination`), and by applying the same treatment to the handlers
+ * composed through `astro/logger/compose`.
+ *
+ * Concretely, a `URL` entrypoint becomes an absolute file path — mirroring what session
+ * drivers do, since both Vite and `import()` can handle those — while a string entrypoint,
+ * e.g. a package specifier, is left untouched.
+ */
+export declare function normalizeLoggerConfig(logger: LoggerHandlerConfig): NormalizedLoggerConfig;

package/dist/core/logger/utils.js

@@ -0,0 +1,20 @@
+import { fileURLToPath } from "node:url";
+const COMPOSE_LOGGER_ENTRYPOINT = "astro/logger/compose";
+function normalizeLoggerConfig(logger) {
+  const entrypoint = normalizeEntrypoint(logger.entrypoint);
+  if (entrypoint === COMPOSE_LOGGER_ENTRYPOINT) {
+    const loggers = logger.config?.loggers ?? [];
+    return {
+      entrypoint,
+      loggers: loggers.map((nested) => normalizeLoggerConfig(nested))
+    };
+  }
+  return { entrypoint, config: logger.config };
+}
+function normalizeEntrypoint(entrypoint) {
+  return entrypoint instanceof URL ? fileURLToPath(entrypoint) : entrypoint;
+}
+export {
+  COMPOSE_LOGGER_ENTRYPOINT,
+  normalizeLoggerConfig
+};

package/dist/core/logger/vite-plugin.d.ts

@@ -0,0 +1,30 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../../types/astro.js';
+import { type NormalizedLoggerConfig } from './utils.js';
+export declare const VIRTUAL_LOGGER_ID = "virtual:astro:logger";
+/** Resolves an entrypoint to a module id, or `null` if it cannot be resolved. */
+type ResolveEntrypoint = (entrypoint: string) => Promise<string | null>;
+interface EmittedDestination {
+    /** The expression instantiating the destination, e.g. `_logger0({ level: 'info' })` */
+    expression: string;
+    /** The import statements `expression` depends on, in declaration order */
+    imports: string[];
+}
+/**
+ * Emits the source of a logger destination, so that the handler is part of the bundle
+ * rather than imported at runtime from a path that no longer exists once deployed.
+ *
+ * This is the build-time counterpart of `createDestination()` in `./load.ts`: both walk
+ * the same normalized config, but this one *generates code* that instantiates the
+ * destination, while the Node one instantiates it directly through `import()`.
+ */
+export declare function emitDestination(config: NormalizedLoggerConfig, resolveEntrypoint: ResolveEntrypoint, 
+/**
+ * Import names must be unique across the whole virtual module, so nested
+ * destinations continue numbering where their parent left off.
+ */
+nameOffset?: number): Promise<EmittedDestination>;
+export declare function vitePluginLogger({ settings, }: {
+    settings: AstroSettings;
+}): VitePlugin | undefined;
+export {};

package/dist/core/logger/vite-plugin.js

@@ -0,0 +1,79 @@
+import { fileURLToPath } from "node:url";
+import { UnableToLoadLogger } from "../errors/errors-data.js";
+import { AstroError } from "../errors/index.js";
+import { normalizeLoggerConfig } from "./utils.js";
+const VIRTUAL_LOGGER_ID = "virtual:astro:logger";
+const RESOLVED_VIRTUAL_LOGGER_ID = "\0" + VIRTUAL_LOGGER_ID;
+async function emitDestination(config, resolveEntrypoint, nameOffset = 0) {
+  let resolved = null;
+  let cause;
+  try {
+    resolved = await resolveEntrypoint(config.entrypoint);
+  } catch (e) {
+    cause = e;
+  }
+  if (!resolved) {
+    const error = new AstroError({
+      ...UnableToLoadLogger,
+      message: UnableToLoadLogger.message(config.entrypoint)
+    });
+    if (cause instanceof Error) {
+      error.cause = cause;
+    }
+    throw error;
+  }
+  const name = `_logger${nameOffset}`;
+  const imports = [`import ${name} from ${JSON.stringify(resolved)};`];
+  if (config.loggers) {
+    const expressions = [];
+    for (const nested of config.loggers) {
+      const emitted = await emitDestination(nested, resolveEntrypoint, nameOffset + imports.length);
+      imports.push(...emitted.imports);
+      expressions.push(emitted.expression);
+    }
+    return { expression: `${name}([${expressions.join(", ")}])`, imports };
+  }
+  return { expression: `${name}(${JSON.stringify(config.config) ?? "undefined"})`, imports };
+}
+function vitePluginLogger({
+  settings
+}) {
+  const loggerConfig = settings.config.logger;
+  if (!loggerConfig) {
+    return;
+  }
+  return {
+    name: VIRTUAL_LOGGER_ID,
+    enforce: "pre",
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_LOGGER_ID}$`)
+      },
+      handler() {
+        return RESOLVED_VIRTUAL_LOGGER_ID;
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_VIRTUAL_LOGGER_ID}$`)
+      },
+      async handler() {
+        const importerPath = fileURLToPath(new URL("package.json", settings.config.root));
+        const { expression, imports } = await emitDestination(
+          normalizeLoggerConfig(loggerConfig),
+          async (entrypoint) => (await this.resolve(entrypoint, importerPath))?.id ?? null
+        );
+        return {
+          code: `${imports.join("\n")}
+export default ${expression};
+`
+        };
+      }
+    }
+  };
+}
+export {
+  VIRTUAL_LOGGER_ID,
+  emitDestination,
+  vitePluginLogger
+};

package/dist/core/messages/runtime.js

@@ -270,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.1.4"}`
+        `v${"7.1.6"}`
       )} ${headline}`
     );
   }

package/dist/core/routing/handler.js

@@ -93,6 +93,7 @@ class AstroHandler {
     const defaultStatus = this.#app.getDefaultStatusCode(routeData, pathname);
     state.status = defaultStatus;
     let response;
+    let finalizeError;
     try {
       const sessionP = this.#hasSession ? provideSession(state) : void 0;
       const cacheP = provideCache(state);
@@ -143,8 +144,21 @@ class AstroHandler {
         pathname: state.pathname
       });
     } finally {
-      const finalize = state.finalizeAll();
-      if (finalize) await finalize;
+      try {
+        const finalize = state.finalizeAll();
+        if (finalize) await finalize;
+      } catch (err) {
+        finalizeError = err;
+        this.#app.logger.error(null, err.stack || err.message || String(err));
+      }
+    }
+    if (finalizeError) {
+      return this.#app.renderError(request, {
+        ...state.renderOptions,
+        status: 500,
+        error: finalizeError,
+        pathname: state.pathname
+      });
     }
     if (REROUTABLE_STATUS_CODES.includes(response.status) && // If the body isn't null, that means the user sets the 404 status
     // but uses the current route to handle the 404

package/dist/core/sync/index.js

@@ -6,7 +6,7 @@ import colors from "piccolore";
 import { createServer } from "vite";
 import { syncFonts } from "../../assets/fonts/sync.js";
 import { CONTENT_TYPES_FILE } from "../../content/consts.js";
-import { getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
+import { getDataStoreChunkSize, getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
 import { globalContentLayer } from "../../content/instance.js";
 import { createContentTypesGenerator } from "../../content/index.js";
 import { MutableDataStore } from "../../content/mutable-data-store.js";
@@ -59,7 +59,7 @@ async function clearContentLayerCache({
   fs = fsMod,
   isDev
 }) {
-  if (settings.config.experimental.collectionStorage === "chunked") {
+  if (getDataStoreChunkSize(settings) !== void 0) {
     const dataStore = getDataStoreDir(settings, isDev);
     if (fs.existsSync(dataStore)) {
       logger.debug("content", "clearing data store");
@@ -98,9 +98,10 @@ async function syncInternal({
       settings.timer.start("Sync content layer");
       let store;
       try {
-        if (settings.config.experimental.collectionStorage === "chunked") {
+        const chunkSize = getDataStoreChunkSize(settings);
+        if (chunkSize !== void 0) {
           const dataStoreDir = getDataStoreDir(settings, isDev);
-          store = await MutableDataStore.fromDir(dataStoreDir);
+          store = await MutableDataStore.fromDir(dataStoreDir, chunkSize);
         } else {
           const dataStoreFile = getDataStoreFile(settings, isDev);
           store = await MutableDataStore.fromFile(dataStoreFile);

package/dist/manifest/serialized.js

@@ -20,6 +20,7 @@ import { MIDDLEWARE_MODULE_ID } from "../core/middleware/vite-plugin.js";
 import { SERVER_ISLAND_MANIFEST } from "../core/server-islands/vite-plugin-server-islands.js";
 import { VIRTUAL_CACHE_PROVIDER_ID } from "../core/cache/vite-plugin.js";
 import { VIRTUAL_SESSION_DRIVER_ID } from "../core/session/vite-plugin.js";
+import { VIRTUAL_LOGGER_ID } from "../core/logger/vite-plugin.js";
 import { VIRTUAL_PAGES_MODULE_ID } from "../vite-plugin-pages/index.js";
 import { ASTRO_RENDERERS_MODULE_ID } from "../vite-plugin-renderers/index.js";
 import { ASTRO_ROUTES_MODULE_ID } from "../vite-plugin-routes/index.js";
@@ -86,6 +87,7 @@ function serializedManifestPlugin({
         }
         const hasCacheConfig = !!settings.config.cache?.provider;
         const cacheProviderLine = hasCacheConfig ? `cacheProvider: () => import('${VIRTUAL_CACHE_PROVIDER_ID}'),` : "";
+        const loggerLine = settings.config.logger ? `logger: () => import('${VIRTUAL_LOGGER_ID}'),` : "";
         const code = `
 					import { deserializeManifest as _deserializeManifest } from 'astro/app';
 					import { renderers } from '${ASTRO_RENDERERS_MODULE_ID}';
@@ -106,6 +108,7 @@ function serializedManifestPlugin({
 					  middleware: () => import('${MIDDLEWARE_MODULE_ID}'),
 					  sessionDriver: () => import('${VIRTUAL_SESSION_DRIVER_ID}'),
 					  ${cacheProviderLine}
+					  ${loggerLine}
 					  serverIslandMappings: () => import('${SERVER_ISLAND_MANIFEST}'),
 					  routes: manifestRoutes,
 					  pageMap,
@@ -157,10 +160,6 @@ async function createSerializedManifest(settings, encodedKey) {
       styleDirective
     };
   }
-  let loggerConfig = void 0;
-  if (settings.config.logger) {
-    loggerConfig = settings.config.logger;
-  }
   return {
     rootDir: settings.config.root.toString(),
     srcDir: settings.config.srcDir.toString(),
@@ -210,8 +209,7 @@ async function createSerializedManifest(settings, encodedKey) {
       placement: settings.config.devToolbar.placement
     },
     logLevel: settings.logLevel,
-    shouldInjectCspMetaTags: false,
-    loggerConfig
+    shouldInjectCspMetaTags: false
   };
 }
 export {

package/dist/types/public/config.d.ts

@@ -1516,8 +1516,7 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      *
      * By default, Astro uses a built-in logger that outputs human-friendly logs to the console. You can customize this behavior by providing [your own logger handler](https://docs.astro.build/en/reference/logger-reference/#custom-loggers) or by using one of the [built-in log handlers](https://docs.astro.build/en/reference/logger-reference/#built-in-loggers):
      *
-     * ```js
-     * // astro.config.mjs
+     * ```js title="astro.config.mjs"
      * import { defineConfig, logHandlers } from 'astro/config';
      *
      * export default defineConfig({
@@ -1535,7 +1534,8 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      * @version 7.0.0
      * @description
      *
-     * The entrypoint of the log handler. This can be a path to a file in your project or an npm package:
+     * The entrypoint for the [logger implementation](https://docs.astro.build/en/reference/logger-reference/#the-logger-implementation).
+     * This can be an npm package, or a `URL` pointing to a file in your project:
      *
      * ```js title="astro.config.mjs"
      * import { defineConfig } from 'astro/config';
@@ -3128,7 +3128,7 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
         svgOptimizer?: SvgOptimizer;
         /**
          * @name experimental.collectionStorage
-         * @type {'single-file' | 'chunked'}
+         * @type {'single-file' | 'chunked' | { type: 'chunked', chunkSize: number }}
          * @default `'single-file'`
          * @version 7.1.0
          * @description
@@ -3139,22 +3139,31 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
          * file. For very large content collections, this file can grow large
          * enough to hit platform file-size limits.
          *
-         * When set to `'chunked'`, the store is split across many smaller,
-         * content-addressed files so that no single file grows unbounded.
+         * When set to `'chunked'`, the store is split into files
+         * with a maximum size of 20 MiB each. To customize the maximum size,
+         * pass an object with `type: 'chunked'` and `chunkSize`. A 1 MiB limit
+         * is recommended for broad adapter compatibility.
          *
          * ```js
          * import { defineConfig } from 'astro/config';
          *
          * export default defineConfig({
          *   experimental: {
-         *     collectionStorage: 'chunked',
+         *     collectionStorage: {
+         *       type: 'chunked',
+         *       chunkSize: 1024 * 1024,
+         *     },
          *   },
          * });
          * ```
          *
          * See the [experimental data store chunking documentation](https://docs.astro.build/en/reference/experimental-flags/collection-storage/) for more information.
          */
-        collectionStorage?: 'single-file' | 'chunked';
+        collectionStorage?: 'single-file' | 'chunked' | {
+            type: 'chunked';
+            /** Maximum UTF-8 byte size of each data store chunk. */
+            chunkSize: number;
+        };
     };
 }
 /**