astro 5.0.0-beta.1 → 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/actions/runtime/middleware.js

@@ -1,3 +1,4 @@
+import { decodeBase64, encodeBase64 } from "@oslojs/encoding";
 import { yellow } from "kleur/colors";
 import { defineMiddleware } from "../../core/middleware/index.js";
 import { ACTION_QUERY_PARAMS } from "../consts.js";
@@ -6,6 +7,8 @@ import { getAction } from "./virtual/get-action.js";
 import {
   serializeActionResult
 } from "./virtual/shared.js";
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
 const onRequest = defineMiddleware(async (context, next) => {
   if (context.isPrerendered) {
     if (context.request.method === "POST") {
@@ -18,8 +21,9 @@ const onRequest = defineMiddleware(async (context, next) => {
   }
   const locals = context.locals;
   if (locals._actionPayload) return next();
-  const actionPayload = context.cookies.get(ACTION_QUERY_PARAMS.actionPayload)?.json();
-  if (actionPayload) {
+  const actionPayloadCookie = context.cookies.get(ACTION_QUERY_PARAMS.actionPayload)?.value;
+  if (actionPayloadCookie) {
+    const actionPayload = JSON.parse(decoder.decode(decodeBase64(actionPayloadCookie)));
     if (!isActionPayload(actionPayload)) {
       throw new Error("Internal: Invalid action payload in cookie.");
     }
@@ -79,10 +83,15 @@ async function redirectWithResult({
   actionName,
   actionResult
 }) {
-  context.cookies.set(ACTION_QUERY_PARAMS.actionPayload, {
-    actionName,
-    actionResult: serializeActionResult(actionResult)
-  });
+  const cookieValue = encodeBase64(
+    encoder.encode(
+      JSON.stringify({
+        actionName,
+        actionResult: serializeActionResult(actionResult)
+      })
+    )
+  );
+  context.cookies.set(ACTION_QUERY_PARAMS.actionPayload, cookieValue);
   if (actionResult.error) {
     const referer = context.request.headers.get("Referer");
     if (!referer) {

package/dist/actions/runtime/virtual/shared.js

@@ -126,14 +126,24 @@ function serializeActionResult(res) {
     if (import.meta.env?.DEV) {
       actionResultErrorStack.set(res.error.stack);
     }
+    let body2;
+    if (res.error instanceof ActionInputError) {
+      body2 = {
+        type: res.error.type,
+        issues: res.error.issues,
+        fields: res.error.fields
+      };
+    } else {
+      body2 = {
+        ...res.error,
+        message: res.error.message
+      };
+    }
     return {
       type: "error",
       status: res.error.status,
       contentType: "application/json",
-      body: JSON.stringify({
-        ...res.error,
-        message: res.error.message
-      })
+      body: JSON.stringify(body2)
     };
   }
   if (res.data === void 0) {

package/dist/assets/utils/resolveImports.js

@@ -4,7 +4,7 @@ import { shorthash } from "../../runtime/server/shorthash.js";
 import { VALID_INPUT_FORMATS } from "../consts.js";
 function imageSrcToImportId(imageSrc, filePath) {
   imageSrc = removeBase(imageSrc, IMAGE_IMPORT_PREFIX);
-  if (isRemotePath(imageSrc) || imageSrc.startsWith("/")) {
+  if (isRemotePath(imageSrc)) {
     return;
   }
   const ext = imageSrc.split(".").at(-1);

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/container/index.d.ts

@@ -1,3 +1,4 @@
+import './polyfill.js';
 import type { AstroComponentFactory } from '../runtime/server/index.js';
 import type { Props } from '../types/public/common.js';
 import type { AstroUserConfig } from '../types/public/config.js';

package/dist/container/index.js

@@ -1,3 +1,4 @@
+import "./polyfill.js";
 import { posix } from "node:path";
 import { getDefaultClientDirectives } from "../core/client-directive/index.js";
 import { ASTRO_CONFIG_DEFAULTS } from "../core/config/schema.js";
@@ -5,15 +6,18 @@ import { validateConfig } from "../core/config/validate.js";
 import { createKey } from "../core/encryption.js";
 import { Logger } from "../core/logger/core.js";
 import { nodeLogDestination } from "../core/logger/node.js";
+import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
 import { removeLeadingForwardSlash } from "../core/path.js";
 import { RenderContext } from "../core/render-context.js";
 import { getParts, validateSegment } from "../core/routing/manifest/create.js";
 import { getPattern } from "../core/routing/manifest/pattern.js";
 import { ContainerPipeline } from "./pipeline.js";
 function createManifest(manifest, renderers, middleware) {
-  const defaultMiddleware = (_, next) => {
-    return next();
-  };
+  function middlewareInstance() {
+    return {
+      onRequest: middleware ?? NOOP_MIDDLEWARE_FN
+    };
+  }
   return {
     hrefRoot: import.meta.url,
     trailingSlash: manifest?.trailingSlash ?? ASTRO_CONFIG_DEFAULTS.trailingSlash,
@@ -31,7 +35,7 @@ function createManifest(manifest, renderers, middleware) {
     inlinedScripts: manifest?.inlinedScripts ?? /* @__PURE__ */ new Map(),
     i18n: manifest?.i18n,
     checkOrigin: false,
-    middleware: manifest?.middleware ?? middleware ?? defaultMiddleware,
+    middleware: manifest?.middleware ?? middlewareInstance,
     envGetSecretEnabled: false,
     key: createKey()
   };
@@ -256,11 +260,10 @@ class experimental_AstroContainer {
       params: options.params,
       type: routeType
     });
-    const renderContext = RenderContext.create({
+    const renderContext = await RenderContext.create({
       pipeline: this.#pipeline,
       routeData,
       status: 200,
-      middleware: this.#pipeline.middleware,
       request,
       pathname: url.pathname,
       locals: options?.locals ?? {}

package/dist/container/pipeline.js

@@ -67,7 +67,7 @@ class ContainerPipeline extends Pipeline {
         return Promise.resolve(componentInstance);
       },
       renderers: this.manifest.renderers,
-      onRequest: this.manifest.middleware
+      onRequest: this.resolvedMiddleware
     });
   }
   // At the moment it's not used by the container via any public API

package/dist/container/polyfill.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/container/polyfill.js

@@ -0,0 +1,2 @@
+import { applyPolyfills } from "../core/app/node.js";
+applyPolyfills();

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.d.ts

@@ -34,7 +34,7 @@ export declare class ContentLayer {
 }
 export declare function simpleLoader<TData extends {
     id: string;
-}>(handler: () => Array<TData> | Promise<Array<TData>>, context: LoaderContext): Promise<void>;
+}>(handler: () => Array<TData> | Promise<Array<TData>> | Record<string, Record<string, unknown>> | Promise<Record<string, Record<string, unknown>>>, context: LoaderContext): Promise<void>;
 /**
  * Get the path to the data store file.
  * During development, this is in the `.astro` directory so that the Vite watcher can see it.

package/dist/content/content-layer.js

@@ -1,8 +1,10 @@
 import { promises as fs, existsSync } from "node:fs";
 import * as fastq from "fastq";
 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
@@ -158,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);
@@ -176,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 {
@@ -210,10 +208,46 @@ class ContentLayer {
 async function simpleLoader(handler, context) {
   const data = await handler();
   context.store.clear();
-  for (const raw of data) {
-    const item = await context.parseData({ id: raw.id, data: raw });
-    context.store.set({ id: raw.id, data: item });
+  if (Array.isArray(data)) {
+    for (const raw of data) {
+      if (!raw.id) {
+        throw new AstroError({
+          ...AstroErrorData.ContentLoaderInvalidDataError,
+          message: AstroErrorData.ContentLoaderInvalidDataError.message(
+            context.collection,
+            `Entry missing ID:
+${JSON.stringify({ ...raw, id: void 0 }, null, 2)}`
+          )
+        });
+      }
+      const item = await context.parseData({ id: raw.id, data: raw });
+      context.store.set({ id: raw.id, data: item });
+    }
+    return;
+  }
+  if (typeof data === "object") {
+    for (const [id, raw] of Object.entries(data)) {
+      if (raw.id && raw.id !== id) {
+        throw new AstroError({
+          ...AstroErrorData.ContentLoaderInvalidDataError,
+          message: AstroErrorData.ContentLoaderInvalidDataError.message(
+            context.collection,
+            `Object key ${JSON.stringify(id)} does not match ID ${JSON.stringify(raw.id)}`
+          )
+        });
+      }
+      const item = await context.parseData({ id, data: raw });
+      context.store.set({ id, data: item });
+    }
+    return;
   }
+  throw new AstroError({
+    ...AstroErrorData.ExpectedImageOptions,
+    message: AstroErrorData.ContentLoaderInvalidDataError.message(
+      context.collection,
+      `Invalid data type: ${typeof data}`
+    )
+  });
 }
 function getDataStoreFile(settings, isDev) {
   isDev ??= process?.env.NODE_ENV === "development";

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/runtime.d.ts

@@ -81,10 +81,6 @@ export declare function renderEntry(entry: DataEntry | {
     }>;
 }): Promise<{
     Content: AstroComponentFactory;
-} | {
-    Content: any;
-    headings: any;
-    remarkPluginFrontmatter: any;
 }>;
 export declare function createReference({ lookupMap }: {
     lookupMap: ContentLookupMap;

package/dist/content/runtime.js

@@ -313,13 +313,12 @@ async function renderEntry(entry) {
   if (entry.deferredRender) {
     try {
       const { default: contentModules } = await import("astro:content-module-imports");
-      const module = contentModules.get(entry.filePath);
-      const deferredMod = await module();
-      return {
-        Content: deferredMod.Content,
-        headings: deferredMod.getHeadings?.() ?? [],
-        remarkPluginFrontmatter: deferredMod.frontmatter ?? {}
-      };
+      const renderEntryImport = contentModules.get(entry.filePath);
+      return render({
+        collection: "",
+        id: entry.id,
+        renderEntryImport
+      });
     } catch (e) {
       console.error(e);
     }

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,