astro 7.0.9 → 7.1.1

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

@@ -1,15 +1,21 @@
 import { existsSync, promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as devalue from "devalue";
 import { Traverse } from "neotraverse/modern";
 import { imageSrcToImportId, importIdToSymbolName } from "../assets/utils/resolveImports.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { IMAGE_IMPORT_PREFIX } from "./consts.js";
+import { DATA_STORE_MANIFEST_FILE, IMAGE_IMPORT_PREFIX } from "./consts.js";
+import {
+  ChunkedWriter,
+  FileWriter,
+  serializeDataStore
+} from "./data-store-writer.js";
 import { ImmutableDataStore } from "./data-store.js";
 import { contentModuleToId } from "./utils.js";
 const SAVE_DEBOUNCE_MS = 500;
 const MAX_DEPTH = 10;
 class MutableDataStore extends ImmutableDataStore {
-  #file;
+  #writer;
   #assetsFile;
   #modulesFile;
   #saveTimeout;
@@ -201,7 +207,7 @@ ${lines.join(",\n")}]);
       clearTimeout(this.#saveTimeout);
     }
     this.#saveTimeout = void 0;
-    if (this.#file) {
+    if (this.#writer) {
       await this.writeToDisk();
     }
     this.#maybeResolveSavePromise();
@@ -218,7 +224,7 @@ ${lines.join(",\n")}]);
     }
     this.#saveTimeout = setTimeout(async () => {
       this.#saveTimeout = void 0;
-      if (this.#file) {
+      if (this.#writer) {
         await this.writeToDisk();
       }
       this.#maybeResolveSavePromise();
@@ -340,19 +346,13 @@ ${lines.join(",\n")}]);
     return this.#savePromise;
   }
   toString() {
-    const sorted = new Map(
-      [...this._collections.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, collection]) => [
-        key,
-        new Map([...collection.entries()].sort(([a], [b]) => a.localeCompare(b)))
-      ])
-    );
-    return devalue.stringify(sorted);
+    return serializeDataStore(this._collections);
   }
   async writeToDisk() {
     if (!this.#dirty) {
       return;
     }
-    if (!this.#file) {
+    if (!this.#writer) {
       throw new AstroError(AstroErrorData.UnknownFilesystemError);
     }
     if (this.#writeInProgress) {
@@ -362,7 +362,7 @@ ${lines.join(",\n")}]);
     try {
       this.#dirty = false;
       this.#writeInProgress = true;
-      await this.#writeFileAtomic(this.#file, this.toString());
+      await this.#writer.write(this._collections);
     } catch (err) {
       throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
     } finally {
@@ -400,7 +400,7 @@ ${lines.join(",\n")}]);
       if (existsSync(filePath)) {
         const data = await fs.readFile(filePath, "utf-8");
         const store2 = await MutableDataStore.fromString(data);
-        store2.#file = filePath;
+        store2.#writer = new FileWriter(filePath);
         return store2;
       } else {
         await fs.mkdir(new URL("./", filePath), { recursive: true });
@@ -408,7 +408,44 @@ ${lines.join(",\n")}]);
     } catch {
     }
     const store = new MutableDataStore();
-    store.#file = filePath;
+    store.#writer = new FileWriter(filePath);
+    return store;
+  }
+  /**
+   * Loads a MutableDataStore from a chunked store directory (experimental
+   * `collectionStorage: 'chunked'`), 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) {
+    const manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dirPath);
+    if (existsSync(manifestFile)) {
+      try {
+        const manifestData = await fs.readFile(manifestFile, "utf-8");
+        const manifest = JSON.parse(manifestData);
+        const expanded = {};
+        for (const collectionName in manifest) {
+          expanded[collectionName] = await Promise.all(
+            manifest[collectionName].map(
+              (fileName) => fs.readFile(new URL(`./${fileName}`, dirPath), "utf-8")
+            )
+          );
+        }
+        const map = ImmutableDataStore.manifestToMap(expanded);
+        const store2 = await MutableDataStore.fromMap(map);
+        store2.#writer = new ChunkedWriter(dirPath);
+        return store2;
+      } catch (err) {
+        console.warn(
+          `[content] Could not read the chunked data store at ${fileURLToPath(dirPath)}, rebuilding from scratch.`,
+          err
+        );
+      }
+    }
+    await fs.mkdir(dirPath, { recursive: true });
+    const store = new MutableDataStore();
+    store.#writer = new ChunkedWriter(dirPath);
     return store;
   }
 }

package/dist/content/paths.d.ts

@@ -0,0 +1,14 @@
+import type { AstroSettings } from '../types/astro.js';
+/**
+ * Get the path to the data store file.
+ * 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.
+ */
+export declare function getDataStoreFile(settings: AstroSettings, isDev: boolean): URL;
+/**
+ * Get the path to the data store directory, used when the store is split across
+ * multiple files (experimental `collectionStorage: 'chunked'`).
+ * 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.
+ */
+export declare function getDataStoreDir(settings: AstroSettings, isDev: boolean): URL;

package/dist/content/paths.js

@@ -0,0 +1,11 @@
+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 getDataStoreDir(settings, isDev) {
+  return new URL(DATA_STORE_DIR, isDev ? settings.dotAstroDir : settings.config.cacheDir);
+}
+export {
+  getDataStoreDir,
+  getDataStoreFile
+};

package/dist/content/runtime.js

@@ -73,10 +73,10 @@ function createGetCollection({
     }
     const hasFilter = typeof filter === "function";
     const store = await globalDataStore.get();
-    if (store.hasCollection(collection)) {
+    if (await store.hasCollection(collection)) {
       const { default: imageAssetMap } = await import("astro:asset-imports");
       const result = [];
-      for (const rawEntry of store.values(collection)) {
+      for (const rawEntry of await store.values(collection)) {
         const data = updateImageReferencesInData(rawEntry.data, rawEntry.filePath, imageAssetMap);
         let entry = {
           ...rawEntry,
@@ -127,8 +127,8 @@ function createGetEntry({ liveCollections }) {
       });
     }
     const store = await globalDataStore.get();
-    if (store.hasCollection(collection)) {
-      const entry = store.get(collection, lookupId);
+    if (await store.hasCollection(collection)) {
+      const entry = await store.get(collection, lookupId);
       if (!entry) {
         console.warn(`Entry ${collection} \u2192 ${lookupId} was not found.`);
         return;

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

@@ -13,6 +13,7 @@ import {
   ASSET_IMPORTS_VIRTUAL_ID,
   CONTENT_MODULE_FLAG,
   CONTENT_RENDER_FLAG,
+  DATA_STORE_MANIFEST_FILE,
   DATA_STORE_VIRTUAL_ID,
   MODULES_IMPORTS_FILE,
   MODULES_MJS_ID,
@@ -21,7 +22,7 @@ import {
   RESOLVED_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 } from "./consts.js";
-import { getDataStoreFile } from "./content-layer.js";
+import { getDataStoreDir, getDataStoreFile } from "./paths.js";
 import { getContentPaths, isDeferredModule } from "./utils.js";
 const LARGE_DATA_STORE_THRESHOLD = 5 * 1024 * 1024;
 function invalidateAssetImports(viteServer, filePath) {
@@ -70,6 +71,7 @@ function astroContentVirtualModPlugin({
   settings,
   fs
 }) {
+  let dataStoreDir;
   let dataStoreFile;
   let devServer;
   let liveConfig;
@@ -79,7 +81,12 @@ function astroContentVirtualModPlugin({
     enforce: "pre",
     config(_, env) {
       isDev = env.command === "serve";
-      dataStoreFile = getDataStoreFile(settings, env.command === "serve");
+      if (settings.config.experimental.collectionStorage === "chunked") {
+        dataStoreDir = getDataStoreDir(settings, env.command === "serve");
+        dataStoreFile = new URL(DATA_STORE_MANIFEST_FILE, dataStoreDir);
+      } else {
+        dataStoreFile = getDataStoreFile(settings, env.command === "serve");
+      }
       const contentPaths = getContentPaths(
         settings.config,
         void 0,
@@ -172,6 +179,26 @@ function astroContentVirtualModPlugin({
             return { code: "export default new Map()" };
           }
           const jsonData = await fs.promises.readFile(dataStoreFile, "utf-8");
+          if (settings.config.experimental.collectionStorage === "chunked") {
+            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 entries = Object.entries(manifest).map(
+                ([collection, parts]) => `${JSON.stringify(collection)}:[${parts.map(rawImport).join(",")}]`
+              );
+              const code = `export default{${entries.join(",")}}`;
+              return { code, map: { mappings: "" } };
+            } catch (err) {
+              const message = "Could not parse data store manifest JSON file";
+              this.error({ message, id, cause: err });
+            }
+          }
           try {
             const parsed = JSON.parse(jsonData);
             const useRuntimeJsonParse = isDev && Buffer.byteLength(jsonData) > LARGE_DATA_STORE_THRESHOLD;

package/dist/core/app/dev/pipeline.js

@@ -2,6 +2,7 @@ import { Pipeline } from "../../base-pipeline.js";
 import { ASTRO_VERSION } from "../../constants.js";
 import { createModuleScriptElement, createStylesheetElementSet } from "../../render/ssr-element.js";
 import { findRouteToRewrite } from "../../routing/rewrite.js";
+import { stringifyForScript } from "../../../runtime/server/escape.js";
 class NonRunnablePipeline extends Pipeline {
   getName() {
     return "NonRunnablePipeline";
@@ -73,7 +74,7 @@ class NonRunnablePipeline extends Pipeline {
         debugInfo: this.manifest.devToolbar.debugInfoOutput ?? "",
         placement: this.manifest.devToolbar.placement
       };
-      const children = `window.__astro_dev_toolbar__ = ${JSON.stringify(additionalMetadata)}`;
+      const children = `window.__astro_dev_toolbar__ = ${stringifyForScript(additionalMetadata)}`;
       scripts.add({ props: {}, children });
     }
     const { devCSSMap } = await import("virtual:astro:dev-css-all");

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

@@ -4,8 +4,8 @@ import type { AstroMiddlewareInstance } from '../../types/public/common.js';
 import type { AstroConfig, CspAlgorithm, Locales, RemotePattern } from '../../types/public/config.js';
 import type { RouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../types/public/internal.js';
 import type { SinglePageBuiltModule } from '../build/types.js';
-import type { CspDirective } from '../csp/config.js';
-import type { AstroLoggerDestination, AstroLoggerLevel, AstroLoggerMessage } from '../logger/core.js';
+import type { AstroLoggerDestination, AstroLoggerLevel } from '../logger/core.js';
+import type { CspDirective, CspHashEntry, CspResourceEntry } from '../csp/config.js';
 import type { RoutingStrategies } from './common.js';
 import type { CacheProviderFactory, SSRManifestCache } from '../cache/types.js';
 import type { BaseSessionConfig, SessionDriverFactory } from '../session/types.js';
@@ -91,9 +91,9 @@ export type SSRManifest = {
     i18n: SSRManifestI18n | undefined;
     middleware?: () => Promise<AstroMiddlewareInstance> | AstroMiddlewareInstance;
     logger?: () => Promise<{
-        default: AstroLoggerDestination<AstroLoggerMessage>;
+        default: AstroLoggerDestination;
     }> | {
-        default: AstroLoggerDestination<AstroLoggerMessage>;
+        default: AstroLoggerDestination;
     };
     actions?: () => Promise<SSRActions> | SSRActions;
     sessionDriver?: () => Promise<{
@@ -152,15 +152,49 @@ export type SSRManifestI18n = {
     domainLookupTable: Record<string, string>;
     domains: Record<string, string> | undefined;
 };
+/**
+ * The CSP section of the manifest. It mirrors the `security.csp` config: `directives` plus a
+ * `scriptDirective`/`styleDirective`, each holding `resources`/`hashes` entries that carry their
+ * `kind` (`default`/`element`/`attribute`). The `kind` is only interpreted at render time. Astro's
+ * generated hashes are appended to the relevant `hashes` array as `default`-kind entries.
+ */
 export type SSRManifestCSP = {
     cspDestination: 'adapter' | 'meta' | 'header' | undefined;
     algorithm: CspAlgorithm;
+    directives: CspDirective[];
+    /**
+     * @deprecated Use {@linkcode scriptDirective} instead. Holds the `default`-kind `script-src`
+     * hashes (the same values `scriptDirective.hashes` carries with `kind: "default"`).
+     */
     scriptHashes: string[];
+    /**
+     * @deprecated Use {@linkcode scriptDirective} instead. Holds the `default`-kind `script-src`
+     * resources.
+     */
     scriptResources: string[];
+    /**
+     * @deprecated Use {@linkcode scriptDirective}'s `strictDynamic` instead.
+     */
     isStrictDynamic: boolean;
+    /**
+     * @deprecated Use {@linkcode styleDirective} instead. Holds the `default`-kind `style-src`
+     * hashes.
+     */
     styleHashes: string[];
+    /**
+     * @deprecated Use {@linkcode styleDirective} instead. Holds the `default`-kind `style-src`
+     * resources.
+     */
     styleResources: string[];
-    directives: CspDirective[];
+    scriptDirective: {
+        resources: CspResourceEntry[];
+        hashes: CspHashEntry[];
+        strictDynamic: boolean;
+    };
+    styleDirective: {
+        resources: CspResourceEntry[];
+        hashes: CspHashEntry[];
+    };
 };
 export interface SSRManifestSession extends BaseSessionConfig {
     driver: string;

package/dist/core/base-pipeline.d.ts

@@ -6,7 +6,7 @@ import type { RuntimeMode } from '../types/public/config.js';
 import type { RouteData, SSRActions, SSRLoadedRenderer, SSRManifest, SSRResult } from '../types/public/internal.js';
 import type { ServerIslandMappings } from './app/types.js';
 import type { SinglePageBuiltModule } from './build/types.js';
-import type { AstroLogger } from './logger/core.js';
+import { AstroLogger } from './logger/core.js';
 import { RouteCache } from './render/route-cache.js';
 import { type DefaultRouteParams } from './routing/default.js';
 import type { CacheProvider, CacheProviderFactory } from './cache/types.js';

package/dist/core/base-pipeline.js

@@ -2,6 +2,7 @@ import { NOOP_ACTIONS_MOD } from "../actions/noop-actions.js";
 import { createOriginCheckMiddleware } from "./app/origin-check.js";
 import { ActionNotFoundError } from "./errors/errors-data.js";
 import { AstroError } from "./errors/index.js";
+import { AstroLogger } from "./logger/core.js";
 import { NOOP_MIDDLEWARE_FN } from "./middleware/noop-middleware.js";
 import { sequence } from "./middleware/sequence.js";
 import { RedirectSinglePageBuiltModule } from "./redirects/index.js";
@@ -10,7 +11,7 @@ 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 { loadLogger } from "./logger/load.js";
+import { loadLoggerDestination } from "./logger/load.js";
 const PipelineFeatures = {
   redirects: 1 << 0,
   sessions: 1 << 1,
@@ -171,7 +172,10 @@ class Pipeline {
     }
     this.resolvedLogger = true;
     if (this.manifest.loggerConfig) {
-      this.logger = await loadLogger(this.manifest.loggerConfig);
+      this.logger = new AstroLogger({
+        destination: await loadLoggerDestination(this.manifest.loggerConfig),
+        level: this.manifest.logLevel
+      });
     }
     return this.logger;
   }

package/dist/core/build/index.js

@@ -24,13 +24,14 @@ import { ensureProcessNodeEnv } from "../util.js";
 import { collectPagesData } from "./page-data.js";
 import { viteBuild } from "./static-build.js";
 import { getTimeStat } from "./util.js";
-import { warnIfCspWithShiki } from "../messages/runtime.js";
+import { warnIfCspResourceFallbackShadowing, warnIfCspWithShiki } from "../messages/runtime.js";
 async function build(inlineConfig, options = {}) {
   ensureProcessNodeEnv(options.devOutput ? "development" : "production");
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig, "build");
   const logger = await loadOrCreateNodeLogger(astroConfig, inlineConfig ?? {});
   telemetry.record(eventCliSession("build", userConfig));
   warnIfCspWithShiki(astroConfig, logger);
+  warnIfCspResourceFallbackShadowing(astroConfig, logger);
   const settings = await createSettings(
     astroConfig,
     inlineConfig.logLevel,

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

@@ -20,6 +20,7 @@ import {
   trackScriptHashes,
   trackStyleHashes
 } from "../../csp/common.js";
+import { partitionByKind } from "../../csp/runtime.js";
 import { encodeKey } from "../../encryption.js";
 import { fileExtension, joinPaths, prependForwardSlash } from "../../path.js";
 import { DEFAULT_COMPONENTS } from "../../routing/default.js";
@@ -192,25 +193,39 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
   }
   let csp = void 0;
   if (shouldTrackCspHashes(settings.config.security.csp)) {
-    const algorithm = getAlgorithm(settings.config.security.csp);
+    const cspConfig = settings.config.security.csp;
+    const algorithm = getAlgorithm(cspConfig);
     const scriptHashes = [
-      ...getScriptHashes(settings.config.security.csp),
+      ...getScriptHashes(cspConfig),
       ...await trackScriptHashes(internals, settings, algorithm)
     ];
     const styleHashes = [
-      ...getStyleHashes(settings.config.security.csp),
+      ...getStyleHashes(cspConfig),
       ...settings.injectedCsp.styleHashes,
       ...await trackStyleHashes(internals, settings, algorithm)
     ];
+    const scriptDirective = {
+      resources: getScriptResources(cspConfig),
+      hashes: scriptHashes,
+      strictDynamic: getStrictDynamic(cspConfig)
+    };
+    const styleDirective = {
+      resources: getStyleResources(cspConfig),
+      hashes: styleHashes
+    };
+    const scriptDefault = partitionByKind(scriptDirective).default;
+    const styleDefault = partitionByKind(styleDirective).default;
     csp = {
       cspDestination: settings.adapter?.adapterFeatures?.staticHeaders ? "adapter" : void 0,
-      scriptHashes,
-      scriptResources: getScriptResources(settings.config.security.csp),
-      styleHashes,
-      styleResources: getStyleResources(settings.config.security.csp),
       algorithm,
       directives: getDirectives(settings),
-      isStrictDynamic: getStrictDynamic(settings.config.security.csp)
+      scriptHashes: scriptDefault.hashes,
+      scriptResources: scriptDefault.resources,
+      isStrictDynamic: scriptDirective.strictDynamic,
+      styleHashes: styleDefault.hashes,
+      styleResources: styleDefault.resources,
+      scriptDirective,
+      styleDirective
     };
   }
   let internalFetchHeaders = void 0;

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

@@ -80,6 +80,7 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
         clientPrerender: false;
         contentIntellisense: false;
         chromeDevtoolsWorkspace: false;
+        collectionStorage: "single-file";
     };
 };
 export declare const AstroConfigSchema: z.ZodObject<{
@@ -368,12 +369,40 @@ export declare const AstroConfigSchema: z.ZodObject<{
             }>>>;
             directives: z.ZodOptional<z.ZodArray<z.ZodCustom<`base-uri${string}` | `child-src${string}` | `connect-src${string}` | `default-src${string}` | `fenced-frame-src${string}` | `font-src${string}` | `form-action${string}` | `frame-ancestors${string}` | `frame-src${string}` | `img-src${string}` | `manifest-src${string}` | `media-src${string}` | `object-src${string}` | `referrer${string}` | `report-to${string}` | `report-uri${string}` | `require-trusted-types-for${string}` | `sandbox${string}` | `trusted-types${string}` | `upgrade-insecure-requests${string}` | `worker-src${string}`, `base-uri${string}` | `child-src${string}` | `connect-src${string}` | `default-src${string}` | `fenced-frame-src${string}` | `font-src${string}` | `form-action${string}` | `frame-ancestors${string}` | `frame-src${string}` | `img-src${string}` | `manifest-src${string}` | `media-src${string}` | `object-src${string}` | `referrer${string}` | `report-to${string}` | `report-uri${string}` | `require-trusted-types-for${string}` | `sandbox${string}` | `trusted-types${string}` | `upgrade-insecure-requests${string}` | `worker-src${string}`>>>;
             styleDirective: z.ZodOptional<z.ZodObject<{
-                resources: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                hashes: z.ZodOptional<z.ZodArray<z.ZodCustom<`sha256-${string}` | `sha384-${string}` | `sha512-${string}`, `sha256-${string}` | `sha384-${string}` | `sha512-${string}`>>>;
+                resources: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    resource: z.ZodString;
+                    kind: z.ZodEnum<{
+                        default: "default";
+                        attribute: "attribute";
+                        element: "element";
+                    }>;
+                }, z.core.$strip>]>>>;
+                hashes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodCustom<`sha256-${string}` | `sha384-${string}` | `sha512-${string}`, `sha256-${string}` | `sha384-${string}` | `sha512-${string}`>, z.ZodObject<{
+                    hash: z.ZodCustom<`sha256-${string}` | `sha384-${string}` | `sha512-${string}`, `sha256-${string}` | `sha384-${string}` | `sha512-${string}`>;
+                    kind: z.ZodEnum<{
+                        default: "default";
+                        attribute: "attribute";
+                        element: "element";
+                    }>;
+                }, z.core.$strip>]>>>;
             }, z.core.$strip>>;
             scriptDirective: z.ZodOptional<z.ZodObject<{
-                resources: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                hashes: z.ZodOptional<z.ZodArray<z.ZodCustom<`sha256-${string}` | `sha384-${string}` | `sha512-${string}`, `sha256-${string}` | `sha384-${string}` | `sha512-${string}`>>>;
+                resources: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    resource: z.ZodString;
+                    kind: z.ZodEnum<{
+                        default: "default";
+                        attribute: "attribute";
+                        element: "element";
+                    }>;
+                }, z.core.$strip>]>>>;
+                hashes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodCustom<`sha256-${string}` | `sha384-${string}` | `sha512-${string}`, `sha256-${string}` | `sha384-${string}` | `sha512-${string}`>, z.ZodObject<{
+                    hash: z.ZodCustom<`sha256-${string}` | `sha384-${string}` | `sha512-${string}`, `sha256-${string}` | `sha384-${string}` | `sha512-${string}`>;
+                    kind: z.ZodEnum<{
+                        default: "default";
+                        attribute: "attribute";
+                        element: "element";
+                    }>;
+                }, z.core.$strip>]>>>;
                 strictDynamic: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
         }, z.core.$strip>]>>>;
@@ -458,7 +487,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
     }>>>;
     fetchFile: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
     logger: z.ZodOptional<z.ZodObject<{
-        entrypoint: z.ZodString;
+        entrypoint: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strip>>;
     fonts: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -524,6 +553,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";
+        }>>>;
     }, z.core.$strict>>;
     legacy: z.ZodPrefault<z.ZodObject<{
         collectionsBackwardsCompat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;

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

@@ -9,7 +9,12 @@ import { FontFamilySchema } from "../../../assets/fonts/config.js";
 import { SvgOptimizerSchema } from "../../../assets/svg/config.js";
 import { EnvSchema } from "../../../env/schema.js";
 import { CacheSchema, RouteRulesSchema } from "../../cache/config.js";
-import { allowedDirectivesSchema, cspAlgorithmSchema, cspHashSchema } from "../../csp/config.js";
+import {
+  allowedDirectivesSchema,
+  cspAlgorithmSchema,
+  cspHashEntrySchema,
+  cspResourceEntrySchema
+} from "../../csp/config.js";
 import { SessionSchema } from "../../session/config.js";
 const ASTRO_CONFIG_DEFAULTS = {
   root: ".",
@@ -68,7 +73,8 @@ const ASTRO_CONFIG_DEFAULTS = {
   experimental: {
     clientPrerender: false,
     contentIntellisense: false,
-    chromeDevtoolsWorkspace: false
+    chromeDevtoolsWorkspace: false,
+    collectionStorage: "single-file"
   }
 };
 const highlighterTypesSchema = z.union([z.literal("shiki"), z.literal("prism")]).default(syntaxHighlightDefaults.type);
@@ -304,12 +310,12 @@ const AstroConfigSchema = z.object({
         algorithm: cspAlgorithmSchema,
         directives: z.array(allowedDirectivesSchema).optional(),
         styleDirective: z.object({
-          resources: z.array(z.string()).optional(),
-          hashes: z.array(cspHashSchema).optional()
+          resources: z.array(cspResourceEntrySchema).optional(),
+          hashes: z.array(cspHashEntrySchema).optional()
         }).optional(),
         scriptDirective: z.object({
-          resources: z.array(z.string()).optional(),
-          hashes: z.array(cspHashSchema).optional(),
+          resources: z.array(cspResourceEntrySchema).optional(),
+          hashes: z.array(cspHashEntrySchema).optional(),
           strictDynamic: z.boolean().optional()
         }).optional()
       })
@@ -323,7 +329,7 @@ const AstroConfigSchema = z.object({
   prerenderConflictBehavior: z.enum(["error", "warn", "ignore"]).optional().default(ASTRO_CONFIG_DEFAULTS.prerenderConflictBehavior),
   fetchFile: z.string().nullable().optional().default(ASTRO_CONFIG_DEFAULTS.fetchFile),
   logger: z.object({
-    entrypoint: z.string(),
+    entrypoint: z.union([z.string(), z.instanceof(URL)]),
     config: z.record(z.string(), z.any()).optional()
   }).optional(),
   fonts: z.array(FontFamilySchema).optional(),
@@ -333,7 +339,8 @@ const AstroConfigSchema = z.object({
     clientPrerender: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.clientPrerender),
     contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
     chromeDevtoolsWorkspace: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.chromeDevtoolsWorkspace),
-    svgOptimizer: SvgOptimizerSchema.optional()
+    svgOptimizer: SvgOptimizerSchema.optional(),
+    collectionStorage: z.enum(["single-file", "chunked"]).optional().default(ASTRO_CONFIG_DEFAULTS.experimental.collectionStorage)
   }).prefault({}),
   legacy: z.object({
     collectionsBackwardsCompat: z.boolean().optional().default(false)