astro 2.5.6 → 2.6.0

package/dist/@types/astro.d.ts

@@ -73,7 +73,7 @@ export interface CLIFlags {
     drafts?: boolean;
     open?: boolean;
     experimentalAssets?: boolean;
-    experimentalMiddleware?: boolean;
+    experimentalRedirects?: boolean;
 }
 export interface BuildConfig {
     /**
@@ -396,6 +396,50 @@ export interface AstroUserConfig {
      * ```
      */
     cacheDir?: string;
+    /**
+     * @docs
+     * @name redirects (Experimental)
+     * @type {RedirectConfig}
+     * @default `{}`
+     * @version 2.6.0
+     * @description Specify a mapping of redirects where the key is the route to match
+     * and the value is the path to redirect to.
+     *
+     * You can redirect both static and dynamic routes, but only to the same kind of route.
+     * For example you cannot have a `'/article': '/blog/[...slug]'` redirect.
+     *
+     *
+     * ```js
+     * {
+     *   redirects: {
+     *     '/old': '/new',
+     *     '/blog/[...slug]': '/articles/[...slug]',
+     *   }
+     * }
+     * ```
+     *
+     *
+     * For statically-generated sites with no adapter installed, this will produce a client redirect using a [`<meta http-equiv="refresh">` tag](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#http-equiv) and does not support status codes.
+     *
+     * When using SSR or with a static adapter in `output: static`
+     * mode, status codes are supported.
+     * Astro will serve redirected GET requests with a status of `301`
+     * and use a status of `308` for any other request method.
+     *
+     * You can customize the [redirection status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages) using an object in the redirect config:
+     *
+     * ```js
+     * {
+     *   redirects: {
+     *     '/other': {
+     *       status: 302,
+     *       destination: '/place',
+     *     },
+     *   }
+     * }
+     * ```
+     */
+    redirects?: RedirectConfig;
     /**
      * @docs
      * @name site
@@ -670,6 +714,50 @@ export interface AstroUserConfig {
          * ```
          */
         serverEntry?: string;
+        /**
+         * @docs
+         * @name build.redirects
+         * @type {boolean}
+         * @default `true`
+         * @version 2.6.0
+         * @description
+         * Specifies whether redirects will be output to HTML during the build.
+         * This option only applies to `output: 'static'` mode; in SSR redirects
+         * are treated the same as all responses.
+         *
+         * This option is mostly meant to be used by adapters that have special
+         * configuration files for redirects and do not need/want HTML based redirects.
+         *
+         * ```js
+         * {
+         *   build: {
+         *     redirects: false
+         *   }
+         * }
+         * ```
+         */
+        redirects?: boolean;
+        /**
+         * @docs
+         * @name build.inlineStylesheets
+         * @type {('always' | 'auto' | 'never')}
+         * @default `never`
+         * @version 2.6.0
+         * @description
+         * Control whether styles are sent to the browser in a separate css file or inlined into `<style>` tags. Choose from the following options:
+         *  - `'always'` - all styles are inlined into `<style>` tags
+         *  - `'auto'` - only stylesheets smaller than `ViteConfig.build.assetsInlineLimit` (default: 4kb) are inlined. Otherwise, styles are sent in external stylesheets.
+         *  - `'never'` - all styles are sent in external stylesheets
+         *
+         * ```js
+         * {
+         * 	build: {
+         *		inlineStylesheets: `auto`,
+         * 	},
+         * }
+         * ```
+         */
+        inlineStylesheets?: 'always' | 'auto' | 'never';
     };
     /**
      * @docs
@@ -1001,103 +1089,24 @@ export interface AstroUserConfig {
         assets?: boolean;
         /**
          * @docs
-         * @name experimental.inlineStylesheets
-         * @type {('always' | 'auto' | 'never')}
-         * @default `never`
-         * @version 2.4.0
-         * @description
-         * Control whether styles are sent to the browser in a separate css file or inlined into `<style>` tags. Choose from the following options:
-         *  - `'always'` - all styles are inlined into `<style>` tags
-         *  - `'auto'` - only stylesheets smaller than `ViteConfig.build.assetsInlineLimit` (default: 4kb) are inlined. Otherwise, styles are sent in external stylesheets.
-         *  - `'never'` - all styles are sent in external stylesheets
-         *
-         * ```js
-         * {
-         * 	experimental: {
-         *		inlineStylesheets: `auto`,
-         * 	},
-         * }
-         * ```
-         */
-        inlineStylesheets?: 'always' | 'auto' | 'never';
-        /**
-         * @docs
-         * @name experimental.customClientDirectives
-         * @type {boolean}
-         * @default `false`
-         * @version 2.5.0
-         * @description
-         * Allow integrations to use the [experimental `addClientDirective` API](/en/reference/integrations-reference/#addclientdirective-option) in the `astro:config:setup` hook
-         * to add custom client directives in Astro files.
-         *
-         * To enable this feature, set `experimental.customClientDirectives` to `true` in your Astro config:
-         *
-         * ```js
-         * {
-         * 	experimental: {
-         *		customClientDirectives: true,
-         * 	},
-         * }
-         * ```
-         */
-        customClientDirectives?: boolean;
-        /**
-         * @docs
-         * @name experimental.middleware
-         * @type {boolean}
-         * @default `false`
-         * @version 2.4.0
-         * @description
-         * Enable experimental support for Astro middleware.
-         *
-         * To enable this feature, set `experimental.middleware` to `true` in your Astro config:
-         *
-         * ```js
-         * {
-         * 	experimental: {
-         *		middleware: true,
-         * 	},
-         * }
-         * ```
-         */
-        middleware?: boolean;
-        /**
-         * @docs
-         * @name experimental.hybridOutput
+         * @name experimental.redirects
          * @type {boolean}
          * @default `false`
-         * @version 2.5.0
+         * @version 2.6.0
          * @description
-         * Enable experimental support for hybrid SSR with pre-rendering enabled by default.
-         *
-         * To enable this feature, first set `experimental.hybridOutput` to `true` in your Astro config, and set `output` to `hybrid`.
+         * Enable experimental support for redirect configuration. With this enabled
+         * you can set redirects via the top-level `redirects` property. To enable
+         * this feature, set `experimental.redirects` to `true`.
          *
          * ```js
          * {
-         *  output: 'hybrid',
          * 	experimental: {
-         *		hybridOutput: true,
+         *		redirects: true,
          * 	},
          * }
          * ```
-         * Then add `export const prerender =  false` to any page or endpoint you want to opt-out of pre-rendering.
-         * ```astro
-         * ---
-         * // pages/contact.astro
-         * export const prerender = false
-         *
-         * if (Astro.request.method === 'POST') {
-         *  // handle form submission
-         * }
-         * ---
-         * <form method="POST">
-         * 	<input type="text" name="name" />
-         * 	<input type="email" name="email" />
-         * 	<button type="submit">Submit</button>
-         * </form>
-         * ```
          */
-        hybridOutput?: boolean;
+        redirects?: boolean;
     };
     /** @deprecated - Use "integrations" instead. Run Astro to learn more about migrating. */
     renderers?: never;
@@ -1171,6 +1180,12 @@ export interface ContentEntryType {
         viteId: string;
     }): rollup.LoadResult | Promise<rollup.LoadResult>;
     contentModuleTypes?: string;
+    /**
+     * Handle asset propagation for rendered content to avoid bleed.
+     * Ex. MDX content can import styles and scripts, so `handlePropagation` should be true.
+     * @default true
+     */
+    handlePropagation?: boolean;
 }
 type GetContentEntryInfoReturnType = {
     data: Record<string, unknown>;
@@ -1414,6 +1429,7 @@ export interface AstroAdapter {
     args?: any;
 }
 type Body = string;
+export type ValidRedirectStatus = 300 | 301 | 302 | 303 | 304 | 307 | 308;
 interface AstroSharedContext<Props extends Record<string, any> = Record<string, any>> {
     /**
      * The address (usually IP address) of the user. Used with SSR only.
@@ -1442,7 +1458,7 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
     /**
      * Redirect to another page (**SSR Only**).
      */
-    redirect(path: string, status?: 301 | 302 | 303 | 307 | 308): Response;
+    redirect(path: string, status?: ValidRedirectStatus): Response;
     /**
      * Object accessed via Astro middleware
      */
@@ -1625,7 +1641,7 @@ export interface AstroIntegration {
     };
 }
 export type MiddlewareNext<R> = () => Promise<R>;
-export type MiddlewareHandler<R> = (context: APIContext, next: MiddlewareNext<R>) => Promise<R> | Promise<void> | void;
+export type MiddlewareHandler<R> = (context: APIContext, next: MiddlewareNext<R>) => Promise<R> | R | Promise<void> | void;
 export type MiddlewareResponseHandler = MiddlewareHandler<Response>;
 export type MiddlewareEndpointHandler = MiddlewareHandler<Response | EndpointOutput>;
 export type MiddlewareNextResponse = MiddlewareNext<Response>;
@@ -1636,12 +1652,16 @@ export interface AstroPluginOptions {
     settings: AstroSettings;
     logging: LogOptions;
 }
-export type RouteType = 'page' | 'endpoint';
+export type RouteType = 'page' | 'endpoint' | 'redirect';
 export interface RoutePart {
     content: string;
     dynamic: boolean;
     spread: boolean;
 }
+type RedirectConfig = string | {
+    status: ValidRedirectStatus;
+    destination: string;
+};
 export interface RouteData {
     route: string;
     component: string;
@@ -1653,7 +1673,12 @@ export interface RouteData {
     segments: RoutePart[][];
     type: RouteType;
     prerender: boolean;
+    redirect?: RedirectConfig;
+    redirectRoute?: RouteData;
 }
+export type RedirectRouteData = RouteData & {
+    redirect: string;
+};
 export type SerializedRouteData = Omit<RouteData, 'generate' | 'pattern'> & {
     generate: undefined;
     pattern: string;

package/dist/assets/generate.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import { basename, join } from "node:path/posix";
 import { warn } from "../core/logger/core.js";
 import { prependForwardSlash } from "../core/path.js";
-import { isHybridOutput } from "../prerender/utils.js";
+import { isServerLikeOutput } from "../prerender/utils.js";
 import { getConfiguredImageService, isESMImportedImage } from "./internal.js";
 async function generateImage(buildOpts, options, filepath) {
   if (!isESMImportedImage(options.src)) {
@@ -21,7 +21,7 @@ async function generateImage(buildOpts, options, filepath) {
     useCache = false;
   }
   let serverRoot, clientRoot;
-  if (buildOpts.settings.config.output === "server" || isHybridOutput(buildOpts.settings.config)) {
+  if (isServerLikeOutput(buildOpts.settings.config)) {
     serverRoot = buildOpts.settings.config.build.server;
     clientRoot = buildOpts.settings.config.build.client;
   } else {

package/dist/config/index.js

@@ -5,17 +5,21 @@ function getViteConfig(inlineConfig) {
   return async ({ mode, command }) => {
     const cmd = command === "serve" ? "dev" : command;
     const [
+      fs,
       { mergeConfig },
       { nodeLogDestination },
       { openConfig, createSettings },
       { createVite },
-      { runHookConfigSetup, runHookConfigDone }
+      { runHookConfigSetup, runHookConfigDone },
+      { astroContentListenPlugin }
     ] = await Promise.all([
+      import("fs"),
       import("vite"),
       import("../core/logger/node.js"),
       import("../core/config/index.js"),
       import("../core/create-vite.js"),
-      import("../integrations/index.js")
+      import("../integrations/index.js"),
+      import("./vite-plugin-content-listen.js")
     ]);
     const logging = {
       dest: nodeLogDestination,
@@ -29,7 +33,11 @@ function getViteConfig(inlineConfig) {
     await runHookConfigSetup({ settings, command: cmd, logging });
     const viteConfig = await createVite(
       {
-        mode
+        mode,
+        plugins: [
+          // Initialize the content listener
+          astroContentListenPlugin({ settings, logging, fs })
+        ]
       },
       { settings, logging, mode }
     );

package/dist/config/vite-plugin-content-listen.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import type fsMod from 'node:fs';
+import type { Plugin } from 'vite';
+import type { AstroSettings } from '../@types/astro';
+import type { LogOptions } from '../core/logger/core.js';
+/**
+ * Listen for Astro content directory changes and generate types.
+ *
+ * This is a separate plugin for `getViteConfig` as the `attachContentServerListeners` API
+ * needs to be called at different times in `astro dev` and `getViteConfig`. For `astro dev`,
+ * it needs to be called after the Astro server is started (packages/astro/src/core/dev/dev.ts).
+ * For `getViteConfig`, it needs to be called after the Vite server is started.
+ */
+export declare function astroContentListenPlugin({ settings, logging, fs, }: {
+    settings: AstroSettings;
+    logging: LogOptions;
+    fs: typeof fsMod;
+}): Plugin;

package/dist/config/vite-plugin-content-listen.js

@@ -0,0 +1,26 @@
+import { attachContentServerListeners } from "../content/server-listeners.js";
+function astroContentListenPlugin({
+  settings,
+  logging,
+  fs
+}) {
+  let server;
+  return {
+    name: "astro:content-listen",
+    apply: "serve",
+    configureServer(_server) {
+      server = _server;
+    },
+    async buildStart() {
+      await attachContentServerListeners({
+        fs,
+        settings,
+        logging,
+        viteServer: server
+      });
+    }
+  };
+}
+export {
+  astroContentListenPlugin
+};

package/dist/content/consts.d.ts

@@ -1,9 +1,10 @@
 export declare const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
+export declare const CONTENT_RENDER_FLAG = "astroRenderContent";
 export declare const CONTENT_FLAG = "astroContentCollectionEntry";
 export declare const DATA_FLAG = "astroDataCollectionEntry";
-export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroDataCollectionEntry", "astroPropagatedAssets"];
 export declare const VIRTUAL_MODULE_ID = "astro:content";
 export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 export declare const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
+export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroRenderContent", "astroDataCollectionEntry", "astroPropagatedAssets"];
 export declare const CONTENT_TYPES_FILE = "types.d.ts";

package/dist/content/consts.js

@@ -1,15 +1,22 @@
 const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
+const CONTENT_RENDER_FLAG = "astroRenderContent";
 const CONTENT_FLAG = "astroContentCollectionEntry";
 const DATA_FLAG = "astroDataCollectionEntry";
-const CONTENT_FLAGS = [CONTENT_FLAG, DATA_FLAG, PROPAGATED_ASSET_FLAG];
 const VIRTUAL_MODULE_ID = "astro:content";
 const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
+const CONTENT_FLAGS = [
+  CONTENT_FLAG,
+  CONTENT_RENDER_FLAG,
+  DATA_FLAG,
+  PROPAGATED_ASSET_FLAG
+];
 const CONTENT_TYPES_FILE = "types.d.ts";
 export {
   CONTENT_FLAG,
   CONTENT_FLAGS,
+  CONTENT_RENDER_FLAG,
   CONTENT_TYPES_FILE,
   DATA_FLAG,
   LINKS_PLACEHOLDER,

package/dist/content/runtime.js

@@ -184,7 +184,7 @@ async function render({
   id,
   renderEntryImport
 }) {
-  var _a;
+  var _a, _b;
   const UnexpectedRenderError = new AstroError({
     ...AstroErrorData.UnknownContentCollectionError,
     message: `Unexpected error while rendering ${String(collection)} \u2192 ${String(id)}.`
@@ -194,53 +194,70 @@ async function render({
   const baseMod = await renderEntryImport();
   if (baseMod == null || typeof baseMod !== "object")
     throw UnexpectedRenderError;
-  const { collectedStyles, collectedLinks, collectedScripts, getMod } = baseMod;
-  if (typeof getMod !== "function")
-    throw UnexpectedRenderError;
-  const mod = await getMod();
-  if (mod == null || typeof mod !== "object")
+  const { default: defaultMod } = baseMod;
+  if (isPropagatedAssetsModule(defaultMod)) {
+    const { collectedStyles, collectedLinks, collectedScripts, getMod } = defaultMod;
+    if (typeof getMod !== "function")
+      throw UnexpectedRenderError;
+    const propagationMod = await getMod();
+    if (propagationMod == null || typeof propagationMod !== "object")
+      throw UnexpectedRenderError;
+    const Content = createComponent({
+      factory(result, baseProps, slots) {
+        let styles = "", links = "", scripts = "";
+        if (Array.isArray(collectedStyles)) {
+          styles = collectedStyles.map((style) => {
+            return renderUniqueStylesheet(result, {
+              type: "inline",
+              content: style
+            });
+          }).join("");
+        }
+        if (Array.isArray(collectedLinks)) {
+          links = collectedLinks.map((link) => {
+            return renderUniqueStylesheet(result, {
+              type: "external",
+              src: prependForwardSlash(link)
+            });
+          }).join("");
+        }
+        if (Array.isArray(collectedScripts)) {
+          scripts = collectedScripts.map((script) => renderScriptElement(script)).join("");
+        }
+        let props = baseProps;
+        if (id.endsWith("mdx")) {
+          props = {
+            components: propagationMod.components ?? {},
+            ...baseProps
+          };
+        }
+        return createHeadAndContent(
+          unescapeHTML(styles + links + scripts),
+          renderTemplate`${renderComponent(
+            result,
+            "Content",
+            propagationMod.Content,
+            props,
+            slots
+          )}`
+        );
+      },
+      propagation: "self"
+    });
+    return {
+      Content,
+      headings: ((_a = propagationMod.getHeadings) == null ? void 0 : _a.call(propagationMod)) ?? [],
+      remarkPluginFrontmatter: propagationMod.frontmatter ?? {}
+    };
+  } else if (baseMod.Content && typeof baseMod.Content === "function") {
+    return {
+      Content: baseMod.Content,
+      headings: ((_b = baseMod.getHeadings) == null ? void 0 : _b.call(baseMod)) ?? [],
+      remarkPluginFrontmatter: baseMod.frontmatter ?? {}
+    };
+  } else {
     throw UnexpectedRenderError;
-  const Content = createComponent({
-    factory(result, baseProps, slots) {
-      let styles = "", links = "", scripts = "";
-      if (Array.isArray(collectedStyles)) {
-        styles = collectedStyles.map((style) => {
-          return renderUniqueStylesheet(result, {
-            type: "inline",
-            content: style
-          });
-        }).join("");
-      }
-      if (Array.isArray(collectedLinks)) {
-        links = collectedLinks.map((link) => {
-          return renderUniqueStylesheet(result, {
-            type: "external",
-            src: prependForwardSlash(link)
-          });
-        }).join("");
-      }
-      if (Array.isArray(collectedScripts)) {
-        scripts = collectedScripts.map((script) => renderScriptElement(script)).join("");
-      }
-      let props = baseProps;
-      if (id.endsWith(".mdx")) {
-        props = {
-          components: mod.components ?? {},
-          ...baseProps
-        };
-      }
-      return createHeadAndContent(
-        unescapeHTML(styles + links + scripts),
-        renderTemplate`${renderComponent(result, "Content", mod.Content, props, slots)}`
-      );
-    },
-    propagation: "self"
-  });
-  return {
-    Content,
-    headings: ((_a = mod.getHeadings) == null ? void 0 : _a.call(mod)) ?? [],
-    remarkPluginFrontmatter: mod.frontmatter ?? {}
-  };
+  }
 }
 function createReference({ lookupMap }) {
   return function reference(collection) {
@@ -271,6 +288,9 @@ function createReference({ lookupMap }) {
     });
   };
 }
+function isPropagatedAssetsModule(module) {
+  return typeof module === "object" && module != null && "__astroPropagation" in module;
+}
 export {
   createCollectionToGlobResultMap,
   createGetCollection,

package/dist/content/vite-plugin-content-assets.js

@@ -1,4 +1,5 @@
-import { pathToFileURL } from "url";
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
 import { moduleIsTopLevelPage, walkParentInfos } from "../core/build/graph.js";
 import { getPageDataByViteID } from "../core/build/internal.js";
 import { createViteLoader } from "../core/module-loader/vite.js";
@@ -6,15 +7,13 @@ import { joinPaths, prependForwardSlash } from "../core/path.js";
 import { getStylesForURL } from "../core/render/dev/css.js";
 import { getScriptsForURL } from "../core/render/dev/scripts.js";
 import {
+  CONTENT_RENDER_FLAG,
   LINKS_PLACEHOLDER,
   PROPAGATED_ASSET_FLAG,
   SCRIPTS_PLACEHOLDER,
   STYLES_PLACEHOLDER
 } from "./consts.js";
-function isPropagatedAsset(viteId) {
-  const flags = new URLSearchParams(viteId.split("?")[1]);
-  return flags.has(PROPAGATED_ASSET_FLAG);
-}
+import { hasContentFlag } from "./utils.js";
 function astroContentAssetPropagationPlugin({
   mode,
   settings
@@ -22,6 +21,21 @@ function astroContentAssetPropagationPlugin({
   let devModuleLoader;
   return {
     name: "astro:content-asset-propagation",
+    enforce: "pre",
+    async resolveId(id, importer, opts) {
+      if (hasContentFlag(id, CONTENT_RENDER_FLAG)) {
+        const base = id.split("?")[0];
+        for (const { extensions, handlePropagation = true } of settings.contentEntryTypes) {
+          if (handlePropagation && extensions.includes(extname(base))) {
+            return this.resolve(`${base}?${PROPAGATED_ASSET_FLAG}`, importer, {
+              skipSelf: true,
+              ...opts
+            });
+          }
+        }
+        return this.resolve(base, importer, { skipSelf: true, ...opts });
+      }
+    },
     configureServer(server) {
       if (mode === "dev") {
         devModuleLoader = createViteLoader(server);
@@ -29,7 +43,7 @@ function astroContentAssetPropagationPlugin({
     },
     async transform(_, id, options) {
       var _a;
-      if (isPropagatedAsset(id)) {
+      if (hasContentFlag(id, PROPAGATED_ASSET_FLAG)) {
         const basePath = id.split("?")[0];
         let stringifiedLinks, stringifiedStyles, stringifiedScripts;
         if ((options == null ? void 0 : options.ssr) && devModuleLoader) {
@@ -55,12 +69,14 @@ function astroContentAssetPropagationPlugin({
           stringifiedScripts = JSON.stringify(SCRIPTS_PLACEHOLDER);
         }
         const code = `
-					export async function getMod() {
+					async function getMod() {
 						return import(${JSON.stringify(basePath)});
 					}
-					export const collectedLinks = ${stringifiedLinks};
-					export const collectedStyles = ${stringifiedStyles};
-					export const collectedScripts = ${stringifiedScripts};
+					const collectedLinks = ${stringifiedLinks};
+					const collectedStyles = ${stringifiedStyles};
+					const collectedScripts = ${stringifiedScripts};
+					const defaultMod = { __astroPropagation: true, getMod, collectedLinks, collectedStyles, collectedScripts };
+					export default defaultMod;
 				`;
         return { code, map: { mappings: "" } };
       }

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

@@ -29,15 +29,20 @@ function astroContentVirtualModPlugin({
     "@@COLLECTION_NAME_BY_REFERENCE_KEY@@",
     new URL("reference-map.json", contentPaths.cacheDir).pathname
   ).replace("@@CONTENT_DIR@@", relContentDir).replace(
-    "@@CONTENT_ENTRY_GLOB_PATH@@",
-    // [!_] = ignore files starting with "_"
-    `${relContentDir}**/[!_]*${getExtGlob(contentEntryExts)}`
-  ).replace("@@DATA_ENTRY_GLOB_PATH@@", `${relContentDir}**/[!_]*${getExtGlob(dataEntryExts)}`).replace(
-    "@@RENDER_ENTRY_GLOB_PATH@@",
-    `${relContentDir}**/*${getExtGlob(
-      /** Note: data collections excluded */
-      contentEntryExts
-    )}`
+    "'@@CONTENT_ENTRY_GLOB_PATH@@'",
+    JSON.stringify(globWithUnderscoresIgnored(relContentDir, contentEntryExts))
+  ).replace(
+    "'@@DATA_ENTRY_GLOB_PATH@@'",
+    JSON.stringify(globWithUnderscoresIgnored(relContentDir, dataEntryExts))
+  ).replace(
+    "'@@RENDER_ENTRY_GLOB_PATH@@'",
+    JSON.stringify(
+      globWithUnderscoresIgnored(
+        relContentDir,
+        /** Note: data collections excluded */
+        contentEntryExts
+      )
+    )
   );
   const astroContentVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
   return {
@@ -150,6 +155,10 @@ const UnexpectedLookupMapError = new AstroError({
   ...AstroErrorData.UnknownContentCollectionError,
   message: `Unexpected error while parsing content entry IDs and slugs.`
 });
+function globWithUnderscoresIgnored(relContentDir, exts) {
+  const extGlob = getExtGlob(exts);
+  return [`${relContentDir}/**/*${extGlob}`, `!**/_*/**${extGlob}`, `!**/_*${extGlob}`];
+}
 export {
   astroContentVirtualModPlugin,
   getStringifiedLookupMap