astro 5.0.0-beta.2 → 5.0.0-beta.3

package/components/viewtransitions.css

@@ -10,12 +10,22 @@
 @keyframes astroFadeIn {
 	from {
 		opacity: 0;
+		mix-blend-mode: plus-lighter;
+	}
+	to {
+		opacity: 1;
+		mix-blend-mode: plus-lighter;
 	}
 }
 
 @keyframes astroFadeOut {
+	from {
+		opacity: 1;
+		mix-blend-mode: plus-lighter;
+	}
 	to {
 		opacity: 0;
+		mix-blend-mode: plus-lighter;
 	}
 }
 

package/dist/actions/consts.d.ts

@@ -1,6 +1,6 @@
 export declare const VIRTUAL_MODULE_ID = "astro:actions";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
-export declare const ACTIONS_TYPES_FILE = "astro/actions.d.ts";
+export declare const ACTIONS_TYPES_FILE = "actions.d.ts";
 export declare const VIRTUAL_INTERNAL_MODULE_ID = "astro:internal-actions";
 export declare const RESOLVED_VIRTUAL_INTERNAL_MODULE_ID = "\0astro:internal-actions";
 export declare const NOOP_ACTIONS = "\0noop-actions";

package/dist/actions/consts.js

@@ -1,6 +1,6 @@
 const VIRTUAL_MODULE_ID = "astro:actions";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-const ACTIONS_TYPES_FILE = "astro/actions.d.ts";
+const ACTIONS_TYPES_FILE = "actions.d.ts";
 const VIRTUAL_INTERNAL_MODULE_ID = "astro:internal-actions";
 const RESOLVED_VIRTUAL_INTERNAL_MODULE_ID = "\0astro:internal-actions";
 const NOOP_ACTIONS = "\0noop-actions";

package/dist/cli/add/index.js

@@ -6,11 +6,11 @@ import { diffWords } from "diff";
 import { bold, cyan, dim, green, magenta, red, yellow } from "kleur/colors";
 import { builders, generateCode, loadFile } from "magicast";
 import { getDefaultExportOptions } from "magicast/helpers";
-import ora from "ora";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
 import maxSatisfying from "semver/ranges/max-satisfying.js";
 import { exec } from "tinyexec";
+import yoctoSpinner from "yocto-spinner";
 import {
   loadTSConfig,
   resolveConfig,
@@ -381,9 +381,6 @@ function setAdapter(mod, adapter, exportName) {
       from: exportName
     });
   }
-  if (!config.output) {
-    config.output = "server";
-  }
   switch (adapter.id) {
     case "node":
       config.adapter = builders.functionCall(adapterId, { mode: "standalone" });
@@ -494,7 +491,8 @@ async function resolveRangeToInstallSpecifier(name, range) {
   const versions = await fetchPackageVersions(name);
   if (versions instanceof Error) return name;
   const stableVersions = versions.filter((v) => !v.includes("-"));
-  const maxStable = maxSatisfying(stableVersions.length !== 0 ? stableVersions : versions, range);
+  const maxStable = maxSatisfying(stableVersions, range) ?? maxSatisfying(versions, range);
+  if (!maxStable) return name;
   return `${name}@^${maxStable}`;
 }
 const INHERITED_FLAGS = /* @__PURE__ */ new Set([
@@ -545,7 +543,7 @@ ${boxen(coloredOutput, {
 ${message}`
     );
     if (await askToContinue({ flags })) {
-      const spinner = ora("Installing dependencies...").start();
+      const spinner = yoctoSpinner({ text: "Installing dependencies..." }).start();
       try {
         await exec(
           installCommand.pm,
@@ -563,10 +561,10 @@ ${message}`
             }
           }
         );
-        spinner.succeed();
+        spinner.success();
         return 1 /* updated */;
       } catch (err) {
-        spinner.fail();
+        spinner.error();
         logger.debug("add", "Error installing dependencies", err);
         console.error("\n", err.stdout || err.message, "\n");
         return 3 /* failure */;
@@ -577,7 +575,7 @@ ${message}`
   }
 }
 async function validateIntegrations(integrations) {
-  const spinner = ora("Resolving packages...").start();
+  const spinner = yoctoSpinner({ text: "Resolving packages..." }).start();
   try {
     const integrationEntries = await Promise.all(
       integrations.map(async (integration) => {
@@ -594,9 +592,9 @@ async function validateIntegrations(integrations) {
           const firstPartyPkgCheck = await fetchPackageJson("@astrojs", name, tag);
           if (firstPartyPkgCheck instanceof Error) {
             if (firstPartyPkgCheck.message) {
-              spinner.warn(yellow(firstPartyPkgCheck.message));
+              spinner.warning(yellow(firstPartyPkgCheck.message));
             }
-            spinner.warn(yellow(`${bold(integration)} is not an official Astro package.`));
+            spinner.warning(yellow(`${bold(integration)} is not an official Astro package.`));
             const response = await prompts({
               type: "confirm",
               name: "askToContinue",
@@ -621,7 +619,7 @@ async function validateIntegrations(integrations) {
           const thirdPartyPkgCheck = await fetchPackageJson(scope, name, tag);
           if (thirdPartyPkgCheck instanceof Error) {
             if (thirdPartyPkgCheck.message) {
-              spinner.warn(yellow(thirdPartyPkgCheck.message));
+              spinner.warning(yellow(thirdPartyPkgCheck.message));
             }
             throw new Error(`Unable to fetch ${bold(integration)}. Does the package exist?`);
           } else {
@@ -661,11 +659,11 @@ async function validateIntegrations(integrations) {
         return { id: integration, packageName, dependencies, type: integrationType };
       })
     );
-    spinner.succeed();
+    spinner.success();
     return integrationEntries;
   } catch (e) {
     if (e instanceof Error) {
-      spinner.fail(e.message);
+      spinner.error(e.message);
       process.exit(1);
     } else {
       throw e;

package/dist/cli/install-package.js

@@ -2,11 +2,11 @@ import { createRequire } from "node:module";
 import boxen from "boxen";
 import ci from "ci-info";
 import { bold, cyan, dim, magenta } from "kleur/colors";
-import ora from "ora";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
 import { exec } from "tinyexec";
 import whichPm from "which-pm";
+import yoctoSpinner from "yocto-spinner";
 const require2 = createRequire(import.meta.url);
 async function getPackage(packageName, logger, options, otherDeps = []) {
   try {
@@ -104,18 +104,18 @@ ${message}`
     })).askToContinue;
   }
   if (Boolean(response)) {
-    const spinner = ora("Installing dependencies...").start();
+    const spinner = yoctoSpinner({ text: "Installing dependencies..." }).start();
     try {
       await exec(
         installCommand.pm,
         [installCommand.command, ...installCommand.flags, ...installCommand.dependencies],
         { nodeOptions: { cwd } }
       );
-      spinner.succeed();
+      spinner.success();
       return true;
     } catch (err) {
       logger.debug("add", "Error installing dependencies", err);
-      spinner.fail();
+      spinner.error();
       return false;
     }
   } else {

package/dist/content/consts.d.ts

@@ -17,8 +17,10 @@ export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 export declare const IMAGE_IMPORT_PREFIX = "__ASTRO_IMAGE_";
 export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroRenderContent", "astroDataCollectionEntry", "astroPropagatedAssets", "astroContentImageFlag", "astroContentModuleFlag"];
-export declare const CONTENT_TYPES_FILE = "astro/content.d.ts";
+export declare const CONTENT_TYPES_FILE = "content.d.ts";
 export declare const DATA_STORE_FILE = "data-store.json";
-export declare const ASSET_IMPORTS_FILE = "assets.mjs";
-export declare const MODULES_IMPORTS_FILE = "modules.mjs";
+export declare const ASSET_IMPORTS_FILE = "content-assets.mjs";
+export declare const MODULES_IMPORTS_FILE = "content-modules.mjs";
+export declare const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
+export declare const COLLECTIONS_DIR = "collections/";
 export declare const CONTENT_LAYER_TYPE = "content_layer";

package/dist/content/consts.js

@@ -24,15 +24,19 @@ const CONTENT_FLAGS = [
   CONTENT_IMAGE_FLAG,
   CONTENT_MODULE_FLAG
 ];
-const CONTENT_TYPES_FILE = "astro/content.d.ts";
+const CONTENT_TYPES_FILE = "content.d.ts";
 const DATA_STORE_FILE = "data-store.json";
-const ASSET_IMPORTS_FILE = "assets.mjs";
-const MODULES_IMPORTS_FILE = "modules.mjs";
+const ASSET_IMPORTS_FILE = "content-assets.mjs";
+const MODULES_IMPORTS_FILE = "content-modules.mjs";
+const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
+const COLLECTIONS_DIR = "collections/";
 const CONTENT_LAYER_TYPE = "content_layer";
 export {
   ASSET_IMPORTS_FILE,
   ASSET_IMPORTS_RESOLVED_STUB_ID,
   ASSET_IMPORTS_VIRTUAL_ID,
+  COLLECTIONS_DIR,
+  COLLECTIONS_MANIFEST_FILE,
   CONTENT_FLAG,
   CONTENT_FLAGS,
   CONTENT_IMAGE_FLAG,

package/dist/content/content-layer.js

@@ -4,6 +4,7 @@ import xxhash from "xxhash-wasm";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import {
   ASSET_IMPORTS_FILE,
+  COLLECTIONS_MANIFEST_FILE,
   CONTENT_LAYER_TYPE,
   DATA_STORE_FILE,
   MODULES_IMPORTS_FILE
@@ -159,14 +160,10 @@ class ContentLayer {
         return collection.loader.load(context);
       })
     );
-    if (!existsSync(this.#settings.config.cacheDir)) {
-      await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
-    }
+    await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
+    await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
     const cacheFile = getDataStoreFile(this.#settings);
     await this.#store.writeToDisk(cacheFile);
-    if (!existsSync(this.#settings.dotAstroDir)) {
-      await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
-    }
     const assetImportsFile = new URL(ASSET_IMPORTS_FILE, this.#settings.dotAstroDir);
     await this.#store.writeAssetImports(assetImportsFile);
     const modulesImportsFile = new URL(MODULES_IMPORTS_FILE, this.#settings.dotAstroDir);
@@ -177,7 +174,7 @@ class ContentLayer {
     }
   }
   async regenerateCollectionFileManifest() {
-    const collectionsManifest = new URL("collections/collections.json", this.#settings.dotAstroDir);
+    const collectionsManifest = new URL(COLLECTIONS_MANIFEST_FILE, this.#settings.dotAstroDir);
     this.#logger.debug("content", "Regenerating collection file manifest");
     if (existsSync(collectionsManifest)) {
       try {

package/dist/content/loaders/file.d.ts

@@ -1,7 +1,14 @@
 import type { Loader } from './types.js';
+export interface FileOptions {
+    /**
+     * the parsing function to use for this data
+     * @default JSON.parse or yaml.load, depending on the extension of the file
+     * */
+    parser?: (text: string) => Record<string, Record<string, unknown>> | Array<Record<string, unknown>>;
+}
 /**
  * Loads entries from a JSON file. The file must contain an array of objects that contain unique `id` fields, or an object with string keys.
- * @todo Add support for other file types, such as YAML, CSV etc.
  * @param fileName The path to the JSON file to load, relative to the content directory.
+ * @param options Additional options for the file loader
  */
-export declare function file(fileName: string): Loader;
+export declare function file(fileName: string, options?: FileOptions): Loader;

package/dist/content/loaders/file.js

@@ -1,43 +1,59 @@
 import { promises as fs, existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import yaml from "js-yaml";
 import { posixRelative } from "../utils.js";
-function file(fileName) {
+function file(fileName, options) {
   if (fileName.includes("*")) {
     throw new Error("Glob patterns are not supported in `file` loader. Use `glob` loader instead.");
   }
+  let parse = null;
+  const ext = fileName.split(".").at(-1);
+  if (ext === "json") {
+    parse = JSON.parse;
+  } else if (ext === "yml" || ext === "yaml") {
+    parse = (text) => yaml.load(text, {
+      filename: fileName
+    });
+  }
+  if (options?.parser) parse = options.parser;
+  if (parse === null) {
+    throw new Error(
+      `No parser found for file '${fileName}'. Try passing a parser to the \`file\` loader.`
+    );
+  }
   async function syncData(filePath, { logger, parseData, store, config }) {
-    let json;
+    let data;
     try {
-      const data = await fs.readFile(filePath, "utf-8");
-      json = JSON.parse(data);
+      const contents = await fs.readFile(filePath, "utf-8");
+      data = parse(contents);
     } catch (error) {
       logger.error(`Error reading data from ${fileName}`);
       logger.debug(error.message);
       return;
     }
     const normalizedFilePath = posixRelative(fileURLToPath(config.root), filePath);
-    if (Array.isArray(json)) {
-      if (json.length === 0) {
+    if (Array.isArray(data)) {
+      if (data.length === 0) {
         logger.warn(`No items found in ${fileName}`);
       }
-      logger.debug(`Found ${json.length} item array in ${fileName}`);
+      logger.debug(`Found ${data.length} item array in ${fileName}`);
       store.clear();
-      for (const rawItem of json) {
+      for (const rawItem of data) {
         const id = (rawItem.id ?? rawItem.slug)?.toString();
         if (!id) {
           logger.error(`Item in ${fileName} is missing an id or slug field.`);
           continue;
         }
-        const data = await parseData({ id, data: rawItem, filePath });
-        store.set({ id, data, filePath: normalizedFilePath });
+        const parsedData = await parseData({ id, data: rawItem, filePath });
+        store.set({ id, data: parsedData, filePath: normalizedFilePath });
       }
-    } else if (typeof json === "object") {
-      const entries = Object.entries(json);
+    } else if (typeof data === "object") {
+      const entries = Object.entries(data);
       logger.debug(`Found object with ${entries.length} entries in ${fileName}`);
       store.clear();
       for (const [id, rawItem] of entries) {
-        const data = await parseData({ id, data: rawItem, filePath });
-        store.set({ id, data, filePath: normalizedFilePath });
+        const parsedData = await parseData({ id, data: rawItem, filePath });
+        store.set({ id, data: parsedData, filePath: normalizedFilePath });
       }
     } else {
       logger.error(`Invalid data in ${fileName}. Must be an array or object.`);

package/dist/content/types-generator.js

@@ -9,7 +9,12 @@ import { printNode, zodToTs } from "zod-to-ts";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
 import { isRelativePath } from "../core/path.js";
-import { CONTENT_LAYER_TYPE, CONTENT_TYPES_FILE, VIRTUAL_MODULE_ID } from "./consts.js";
+import {
+  COLLECTIONS_DIR,
+  CONTENT_LAYER_TYPE,
+  CONTENT_TYPES_FILE,
+  VIRTUAL_MODULE_ID
+} from "./consts.js";
 import {
   getContentEntryIdAndSlug,
   getContentPaths,
@@ -313,10 +318,8 @@ async function writeContentFiles({
 }) {
   let contentTypesStr = "";
   let dataTypesStr = "";
-  const collectionSchemasDir = new URL("./collections/", settings.dotAstroDir);
-  if (!fs.existsSync(collectionSchemasDir)) {
-    fs.mkdirSync(collectionSchemasDir, { recursive: true });
-  }
+  const collectionSchemasDir = new URL(COLLECTIONS_DIR, settings.dotAstroDir);
+  fs.mkdirSync(collectionSchemasDir, { recursive: true });
   for (const [collection, config] of Object.entries(contentConfig?.collections ?? {})) {
     collectionEntryMap[JSON.stringify(collection)] ??= {
       type: config.type,
@@ -391,7 +394,8 @@ async function writeContentFiles({
   id: string;
   collection: ${collectionKey};
   data: ${dataType};
-  rendered?: RenderedContent 
+  rendered?: RenderedContent;
+  filePath?: string 
 }>;
 `;
         break;
@@ -458,11 +462,8 @@ async function writeContentFiles({
       JSON.stringify(contentCollectionManifest, null, 2)
     );
   }
-  if (!fs.existsSync(settings.dotAstroDir)) {
-    fs.mkdirSync(settings.dotAstroDir, { recursive: true });
-  }
   const configPathRelativeToCacheDir = normalizeConfigPath(
-    new URL("astro", settings.dotAstroDir).pathname,
+    settings.dotAstroDir.pathname,
     contentPaths.config.url.pathname
   );
   for (const contentEntryType of contentEntryTypes) {
@@ -477,9 +478,11 @@ async function writeContentFiles({
     contentConfig ? `typeof import(${configPathRelativeToCacheDir})` : "never"
   );
   if (settings.injectedTypes.some((t) => t.filename === CONTENT_TYPES_FILE)) {
-    const filePath = fileURLToPath(new URL(CONTENT_TYPES_FILE, settings.dotAstroDir));
-    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.promises.writeFile(filePath, typeTemplateContent, "utf-8");
+    await fs.promises.writeFile(
+      new URL(CONTENT_TYPES_FILE, settings.dotAstroDir),
+      typeTemplateContent,
+      "utf-8"
+    );
   } else {
     settings.injectedTypes.push({
       filename: CONTENT_TYPES_FILE,

package/dist/content/utils.d.ts

@@ -1,5 +1,4 @@
 import fsMod from 'node:fs';
-import matter from 'gray-matter';
 import type { PluginContext } from 'rollup';
 import type { ViteDevServer } from 'vite';
 import { z } from 'zod';
@@ -498,7 +497,7 @@ export declare function getContentEntryIdAndSlug({ entry, contentDir, collection
     slug: string;
 };
 export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
-export declare function safeParseFrontmatter(source: string, id?: string): matter.GrayMatterFile<string>;
+export declare function safeParseFrontmatter(source: string, id?: string): import("@astrojs/markdown-remark").ParseFrontmatterResult;
 /**
  * The content config is loaded separately from other `src/` files.
  * This global observable lets dependent plugins (like the content flag plugin)

package/dist/content/utils.js

@@ -1,8 +1,8 @@
 import fsMod from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { parseFrontmatter } from "@astrojs/markdown-remark";
 import { slug as githubSlug } from "github-slugger";
-import matter from "gray-matter";
 import xxhash from "xxhash-wasm";
 import { z } from "zod";
 import { AstroError, AstroErrorData, MarkdownError, errorMap } from "../core/errors/index.js";
@@ -321,7 +321,7 @@ function getYAMLErrorLine(rawData, objectKey) {
 }
 function safeParseFrontmatter(source, id) {
   try {
-    return matter(source);
+    return parseFrontmatter(source, { frontmatter: "empty-with-spaces" });
   } catch (err) {
     const markdownError = new MarkdownError({
       name: "MarkdownError",

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

@@ -7,12 +7,10 @@ interface AstroContentVirtualModPluginParams {
     fs: typeof nodeFs;
 }
 export declare function astroContentVirtualModPlugin({ settings, fs, }: AstroContentVirtualModPluginParams): Plugin;
-export declare function generateContentEntryFile({ settings, lookupMap, IS_DEV, IS_SERVER, isClient, }: {
+export declare function generateContentEntryFile({ settings, lookupMap, isClient, }: {
     settings: AstroSettings;
     fs: typeof nodeFs;
     lookupMap: ContentLookupMap;
-    IS_DEV: boolean;
-    IS_SERVER: boolean;
     isClient: boolean;
 }): Promise<string>;
 /**

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

@@ -4,9 +4,8 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { dataToEsm } from "@rollup/pluginutils";
 import glob from "fast-glob";
 import pLimit from "p-limit";
-import { encodeName } from "../core/build/util.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { appendForwardSlash, removeFileExtension } from "../core/path.js";
+import { appendForwardSlash } from "../core/path.js";
 import { rootRelativePath } from "../core/viteUtils.js";
 import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
 import {
@@ -42,7 +41,6 @@ function astroContentVirtualModPlugin({
   fs
 }) {
   let IS_DEV = false;
-  const IS_SERVER = settings.buildOutput === "server";
   let dataStoreFile;
   return {
     name: "astro-content-virtual-mod-plugin",
@@ -53,14 +51,7 @@ function astroContentVirtualModPlugin({
     },
     async resolveId(id) {
       if (id === VIRTUAL_MODULE_ID) {
-        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 };
-        }
+        return RESOLVED_VIRTUAL_MODULE_ID;
       }
       if (id === DATA_STORE_VIRTUAL_ID) {
         return RESOLVED_DATA_STORE_VIRTUAL_ID;
@@ -103,8 +94,6 @@ function astroContentVirtualModPlugin({
           settings,
           fs,
           lookupMap,
-          IS_DEV,
-          IS_SERVER,
           isClient
         });
         const astro = createDefaultAstroMetadata();
@@ -149,16 +138,6 @@ function astroContentVirtualModPlugin({
         return fs.readFileSync(modules, "utf-8");
       }
     },
-    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`);
-      }
-    },
     configureServer(server) {
       const dataStorePath = fileURLToPath(dataStoreFile);
       server.watcher.add(dataStorePath);
@@ -188,8 +167,6 @@ function astroContentVirtualModPlugin({
 async function generateContentEntryFile({
   settings,
   lookupMap,
-  IS_DEV,
-  IS_SERVER,
   isClient
 }) {
   const contentPaths = getContentPaths(settings.config);
@@ -197,32 +174,22 @@ async function generateContentEntryFile({
   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 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
+  );
   let virtualModContents;
   if (isClient) {
     throw new AstroError({
@@ -234,30 +201,6 @@ async function generateContentEntryFile({
   }
   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

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

@@ -53,7 +53,7 @@ export declare class App {
     removeBase(pathname: string): string;
     match(request: Request): RouteData | undefined;
     render(request: Request, renderOptions?: RenderOptions): Promise<Response>;
-    setCookieHeaders(response: Response): Generator<string, string[], unknown>;
+    setCookieHeaders(response: Response): Generator<string, string[], any>;
     /**
      * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
      * For example,

package/dist/core/build/generate.js

@@ -384,7 +384,7 @@ function createBuildManifest(settings, internals, renderers, middleware, key) {
         onRequest: middleware
       };
     },
-    checkOrigin: settings.config.security?.checkOrigin ?? false,
+    checkOrigin: (settings.config.security?.checkOrigin && settings.buildOutput === "server") ?? false,
     key,
     envGetSecretEnabled: false
   };

package/dist/core/build/index.js

@@ -34,14 +34,6 @@ async function build(inlineConfig, options = {}) {
   telemetry.record(eventCliSession("build", userConfig));
   const settings = await createSettings(astroConfig, fileURLToPath(astroConfig.root));
   if (inlineConfig.force) {
-    if (astroConfig.experimental.contentCollectionCache) {
-      const contentCacheDir = new URL("./content/", astroConfig.cacheDir);
-      if (fs.existsSync(contentCacheDir)) {
-        logger.debug("content", "clearing content cache");
-        await fs.promises.rm(contentCacheDir, { force: true, recursive: true });
-        logger.warn("content", "content cache cleared (force)");
-      }
-    }
     await clearContentLayerCache({ settings, logger, fs });
   }
   const builder = new AstroBuilder(settings, {
@@ -170,8 +162,7 @@ class AstroBuilder {
       settings: this.settings,
       pages: pageNames,
       routes: Object.values(allPages).flat().map((pageData) => pageData.route).concat(hasServerIslands ? getServerIslandRouteData(this.settings.config) : []),
-      logging: this.logger,
-      cacheManifest: internals.cacheManifestUsed
+      logging: this.logger
     });
     if (this.logger.level && levels[this.logger.level()] <= levels["info"]) {
       await this.printStats({

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

@@ -58,8 +58,6 @@ export interface BuildInternals {
      * These will be used as the top-level entrypoints for the client build.
      */
     discoveredScripts: Set<string>;
-    cachedClientEntries: string[];
-    cacheManifestUsed: boolean;
     /**
      * Map of propagated module ids (usually something like `/Users/...blog.mdx?astroPropagatedAssets`)
      * to a set of stylesheets that it uses.