astro 5.1.2 → 5.1.4

package/components/Image.astro

@@ -4,7 +4,6 @@ import type { UnresolvedImageTransform } from '../dist/assets/types';
 import { applyResponsiveAttributes } from '../dist/assets/utils/imageAttributes.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 import type { HTMLAttributes } from '../types';
-import './image.css';
 
 // The TypeScript diagnostic for JSX props uses the last member of the union to suggest props, so it would be better for
 // LocalImageProps to be last. Unfortunately, when we do this the error messages that remote images get are complete nonsense

package/components/Picture.astro

@@ -10,9 +10,8 @@ import type {
 	UnresolvedImageTransform,
 } from '../dist/types/public/index.js';
 import type { HTMLAttributes } from '../types';
-import './image.css';
 
-type Props = (LocalImageProps | RemoteImageProps) & {
+export type Props = (LocalImageProps | RemoteImageProps) & {
 	formats?: ImageOutputFormat[];
 	fallbackFormat?: ImageOutputFormat;
 	pictureAttributes?: HTMLAttributes<'picture'>;

package/components/ResponsiveImage.astro

@@ -0,0 +1,13 @@
+---
+import type { LocalImageProps, RemoteImageProps } from 'astro:assets';
+import Image from './Image.astro';
+
+type Props = LocalImageProps | RemoteImageProps;
+
+const { class: className, ...props } = Astro.props;
+
+import './image.css';
+---
+
+{/* Applying class outside of the spread prevents it from applying unnecessary astro-* classes */}
+<Image {...props} class={className} />

package/components/ResponsivePicture.astro

@@ -0,0 +1,11 @@
+---
+import { default as Picture, type Props as PictureProps } from './Picture.astro';
+
+type Props = PictureProps;
+
+const { class: className, ...props } = Astro.props;
+---
+
+{/* Applying class outside of the spread prevents it from applying unnecessary astro-* classes */}
+
+<Picture {...props} class={className} />

package/dist/assets/build/generate.js

@@ -85,8 +85,10 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     const finalFileURL = new URL("." + filepath, env.clientRoot);
     const finalFolderURL = new URL("./", finalFileURL);
     await fs.promises.mkdir(finalFolderURL, { recursive: true });
-    const cacheFile = basename(filepath) + (isLocalImage ? "" : ".json");
+    const cacheFile = basename(filepath);
     const cachedFileURL = new URL(cacheFile, env.assetsCacheDir);
+    const cacheMetaFile = cacheFile + ".json";
+    const cachedMetaFileURL = new URL(cacheMetaFile, env.assetsCacheDir);
     try {
       if (isLocalImage) {
         await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
@@ -94,15 +96,26 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
           cached: "hit"
         };
       } else {
-        const JSONData = JSON.parse(readFileSync(cachedFileURL, "utf-8"));
-        if (!JSONData.data || !JSONData.expires) {
-          await fs.promises.unlink(cachedFileURL);
+        const JSONData = JSON.parse(readFileSync(cachedMetaFileURL, "utf-8"));
+        if (!JSONData.expires) {
+          try {
+            await fs.promises.unlink(cachedFileURL);
+          } catch {
+          }
+          await fs.promises.unlink(cachedMetaFileURL);
           throw new Error(
             `Malformed cache entry for ${filepath}, cache will be regenerated for this file.`
           );
         }
+        if (JSONData.data) {
+          const { data, ...meta } = JSONData;
+          await Promise.all([
+            fs.promises.writeFile(cachedFileURL, Buffer.from(data, "base64")),
+            writeCacheMetaFile(cachedMetaFileURL, meta, env)
+          ]);
+        }
         if (JSONData.expires > Date.now()) {
-          await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
+          await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
           return {
             cached: "hit"
           };
@@ -116,9 +129,12 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
             if (revalidatedData.data.length) {
               originalImage = revalidatedData;
             } else {
-              revalidatedData.data = Buffer.from(JSONData.data, "base64");
-              await writeRemoteCacheFile(cachedFileURL, revalidatedData, env);
-              await fs.promises.writeFile(finalFileURL, revalidatedData.data);
+              await writeCacheMetaFile(cachedMetaFileURL, revalidatedData, env);
+              await fs.promises.copyFile(
+                cachedFileURL,
+                finalFileURL,
+                fs.constants.COPYFILE_FICLONE
+              );
               return { cached: "revalidated" };
             }
           } catch (e) {
@@ -126,11 +142,12 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
               null,
               `An error was encountered while revalidating a cached remote asset. Proceeding with stale cache. ${e}`
             );
-            await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
+            await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
             return { cached: "hit" };
           }
         }
         await fs.promises.unlink(cachedFileURL);
+        await fs.promises.unlink(cachedMetaFileURL);
       }
     } catch (e) {
       if (e.code !== "ENOENT") {
@@ -169,7 +186,10 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
         if (isLocalImage) {
           await fs.promises.writeFile(cachedFileURL, resultData.data);
         } else {
-          await writeRemoteCacheFile(cachedFileURL, resultData, env);
+          await Promise.all([
+            fs.promises.writeFile(cachedFileURL, resultData.data),
+            writeCacheMetaFile(cachedMetaFileURL, resultData, env)
+          ]);
         }
       }
     } catch (e) {
@@ -190,12 +210,11 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     };
   }
 }
-async function writeRemoteCacheFile(cachedFileURL, resultData, env) {
+async function writeCacheMetaFile(cachedMetaFileURL, resultData, env) {
   try {
     return await fs.promises.writeFile(
-      cachedFileURL,
+      cachedMetaFileURL,
       JSON.stringify({
-        data: Buffer.from(resultData.data).toString("base64"),
         expires: resultData.expires,
         etag: resultData.etag,
         lastModified: resultData.lastModified

package/dist/assets/build/remote.d.ts

@@ -1,5 +1,5 @@
 export type RemoteCacheEntry = {
-    data: string;
+    data?: string;
     expires: number;
     etag?: string;
     lastModified?: string;

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

@@ -70,6 +70,7 @@ function assets({ settings }) {
   globalThis.astroAsset = {
     referencedImages: /* @__PURE__ */ new Set()
   };
+  const imageComponentPrefix = settings.config.experimental.responsiveImages ? "Responsive" : "";
   return [
     // Expose the components and different utilities from `astro:assets`
     {
@@ -92,8 +93,8 @@ function assets({ settings }) {
             `
 					export { getConfiguredImageService, isLocalService } from "astro/assets";
 					import { getImage as getImageInternal } from "astro/assets";
-					export { default as Image } from "astro/components/Image.astro";
-					export { default as Picture } from "astro/components/Picture.astro";
+					export { default as Image } from "astro/components/${imageComponentPrefix}Image.astro";
+					export { default as Picture } from "astro/components/${imageComponentPrefix}Picture.astro";
 					export { inferRemoteSize } from "astro/assets/utils/inferRemoteSize.js";
 
 					export const imageConfig = ${JSON.stringify({ ...settings.config.image, experimentalResponsiveImages: settings.config.experimental.responsiveImages })};

package/dist/content/content-layer.js

@@ -99,15 +99,31 @@ class ContentLayer {
     return this.#queue.add(() => this.#doSync(options));
   }
   async #doSync(options) {
-    const contentConfig = globalContentConfigObserver.get();
+    let contentConfig = globalContentConfigObserver.get();
     const logger = this.#logger.forkIntegrationLogger("content");
+    if (contentConfig?.status === "loading") {
+      contentConfig = await Promise.race([
+        new Promise((resolve) => {
+          const unsub = globalContentConfigObserver.subscribe((ctx) => {
+            unsub();
+            resolve(ctx);
+          });
+        }),
+        new Promise(
+          (resolve) => setTimeout(
+            () => resolve({ status: "error", error: new Error("Content config loading timed out") }),
+            5e3
+          )
+        )
+      ]);
+    }
     if (contentConfig?.status === "error") {
       logger.error(`Error loading content config. Skipping sync.
 ${contentConfig.error.message}`);
       return;
     }
     if (contentConfig?.status !== "loaded") {
-      logger.error("Content config not loaded, skipping sync");
+      logger.error(`Content config not loaded, skipping sync. Status was ${contentConfig?.status}`);
       return;
     }
     logger.info("Syncing content");
@@ -128,11 +144,11 @@ ${contentConfig.error.message}`);
       logger.info("Astro config changed");
       shouldClear = true;
     }
-    if (currentConfigDigest && previousConfigDigest !== currentConfigDigest) {
+    if (previousConfigDigest && previousConfigDigest !== currentConfigDigest) {
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion !== "5.1.2") {
+    if (previousAstroVersion && previousAstroVersion !== "5.1.4") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -140,8 +156,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.1.2") {
-      await this.#store.metaStore().set("astro-version", "5.1.2");
+    if ("5.1.4") {
+      await this.#store.metaStore().set("astro-version", "5.1.4");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/utils.d.ts

@@ -506,7 +506,7 @@ export declare function getContentEntryIdAndSlug({ entry, contentDir, collection
     id: string;
     slug: string;
 };
-export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
+export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir' | 'root'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
 export declare function safeParseFrontmatter(source: string, id?: string): import("@astrojs/markdown-remark").ParseFrontmatterResult;
 /**
  * The content config is loaded separately from other `src/` files.
@@ -549,6 +549,7 @@ type Observable<C> = {
 export type ContentObservable = Observable<ContentCtx>;
 export declare function contentObservable(initialCtx: ContentCtx): ContentObservable;
 export type ContentPaths = {
+    root: URL;
     contentDir: URL;
     assetsDir: URL;
     typesTemplate: URL;
@@ -558,7 +559,7 @@ export type ContentPaths = {
         url: URL;
     };
 };
-export declare function getContentPaths({ srcDir, legacy }: Pick<AstroConfig, 'root' | 'srcDir' | 'legacy'>, fs?: typeof fsMod): ContentPaths;
+export declare function getContentPaths({ srcDir, legacy, root }: Pick<AstroConfig, 'root' | 'srcDir' | 'legacy'>, fs?: typeof fsMod): ContentPaths;
 /**
  * Check for slug in content entry frontmatter and validate the type,
  * falling back to the `generatedSlug` if none is found.

package/dist/content/utils.js

@@ -295,13 +295,20 @@ function getRelativeEntryPath(entry, collection, contentDir) {
   const relativeToCollection = path.relative(collection, relativeToContent);
   return relativeToCollection;
 }
+function isParentDirectory(parent, child) {
+  const relative = path.relative(fileURLToPath(parent), fileURLToPath(child));
+  return !relative.startsWith("..") && !path.isAbsolute(relative);
+}
 function getEntryType(entryPath, paths, contentFileExts, dataFileExts) {
   const { ext } = path.parse(entryPath);
   const fileUrl = pathToFileURL(entryPath);
+  const dotAstroDir = new URL("./.astro/", paths.root);
   if (fileUrl.href === paths.config.url.href) {
     return "config";
   } else if (hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir)) {
     return "ignored";
+  } else if (isParentDirectory(dotAstroDir, fileUrl)) {
+    return "ignored";
   } else if (contentFileExts.includes(ext)) {
     return "content";
   } else if (dataFileExts.includes(ext)) {
@@ -509,10 +516,11 @@ function contentObservable(initialCtx) {
     subscribe
   };
 }
-function getContentPaths({ srcDir, legacy }, fs = fsMod) {
+function getContentPaths({ srcDir, legacy, root }, fs = fsMod) {
   const configStats = search(fs, srcDir, legacy?.collections);
   const pkgBase = new URL("../../", import.meta.url);
   return {
+    root: new URL("./", root),
     contentDir: new URL("./content/", srcDir),
     assetsDir: new URL("./assets/", srcDir),
     typesTemplate: new URL("templates/content/types.d.ts", pkgBase),

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

@@ -36,17 +36,34 @@ import {
   globWithUnderscoresIgnored,
   isDeferredModule
 } from "./utils.js";
+function invalidateDataStore(server) {
+  const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
+  if (module) {
+    server.moduleGraph.invalidateModule(module);
+  }
+  server.ws.send({
+    type: "full-reload",
+    path: "*"
+  });
+}
 function astroContentVirtualModPlugin({
   settings,
   fs
 }) {
   let dataStoreFile;
+  let devServer;
   return {
     name: "astro-content-virtual-mod-plugin",
     enforce: "pre",
     config(_, env) {
       dataStoreFile = getDataStoreFile(settings, env.command === "serve");
     },
+    buildStart() {
+      if (devServer) {
+        devServer.watcher.add(fileURLToPath(dataStoreFile));
+        invalidateDataStore(devServer);
+      }
+    },
     async resolveId(id) {
       if (id === VIRTUAL_MODULE_ID) {
         return RESOLVED_VIRTUAL_MODULE_ID;
@@ -137,26 +154,16 @@ function astroContentVirtualModPlugin({
       }
     },
     configureServer(server) {
+      devServer = server;
       const dataStorePath = fileURLToPath(dataStoreFile);
-      server.watcher.add(dataStorePath);
-      function invalidateDataStore() {
-        const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
-        if (module) {
-          server.moduleGraph.invalidateModule(module);
-        }
-        server.ws.send({
-          type: "full-reload",
-          path: "*"
-        });
-      }
       server.watcher.on("add", (addedPath) => {
         if (addedPath === dataStorePath) {
-          invalidateDataStore();
+          invalidateDataStore(server);
         }
       });
       server.watcher.on("change", (changedPath) => {
         if (changedPath === dataStorePath) {
-          invalidateDataStore();
+          invalidateDataStore(server);
         }
       });
     }

package/dist/core/app/index.js

@@ -89,10 +89,22 @@ class App {
     }
     return pathname;
   }
+  /**
+   * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
+   *
+   * If the decoding fails, it logs the error and return the pathname as is.
+   * @param request
+   * @private
+   */
   #getPathnameFromRequest(request) {
     const url = new URL(request.url);
     const pathname = prependForwardSlash(this.removeBase(url.pathname));
-    return pathname;
+    try {
+      return decodeURI(pathname);
+    } catch (e) {
+      this.getAdapterLogger().error(e.toString());
+      return pathname;
+    }
   }
   match(request) {
     const url = new URL(request.url);
@@ -207,7 +219,7 @@ class App {
       this.#logger.error(null, err.stack || err.message || String(err));
       return this.#renderError(request, { locals, status: 500, error: err, clientAddress });
     } finally {
-      session?.[PERSIST_SYMBOL]();
+      await session?.[PERSIST_SYMBOL]();
     }
     if (REROUTABLE_STATUS_CODES.includes(response.status) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
       return this.#renderError(request, {
@@ -302,7 +314,7 @@ class App {
           });
         }
       } finally {
-        session?.[PERSIST_SYMBOL]();
+        await session?.[PERSIST_SYMBOL]();
       }
     }
     const response = this.#mergeResponses(new Response(null, { status }), originalResponse);

package/dist/core/build/generate.js

@@ -128,7 +128,7 @@ async function generatePage(pageData, ssrEntry, builtPaths, pipeline) {
   async function generatePathWithLogs(path, route, index, paths, isConcurrent) {
     const timeStart = performance.now();
     pipeline.logger.debug("build", `Generating: ${path}`);
-    const filePath = getOutputFilename(config, path, pageData.route.type);
+    const filePath = getOutputFilename(config, path, pageData.route);
     const lineIcon = index === paths.length - 1 && !isConcurrent || paths.length === 1 ? "\u2514\u2500" : "\u251C\u2500";
     if (!isConcurrent) {
       logger.info(null, `  ${blue(lineIcon)} ${dim(filePath)}`, false);

package/dist/core/build/index.js

@@ -19,6 +19,7 @@ import { AstroError, AstroErrorData } from "../errors/index.js";
 import { levels, timerMessage } from "../logger/core.js";
 import { apply as applyPolyfill } from "../polyfill.js";
 import { createRouteManifest } from "../routing/index.js";
+import { getServerIslandRouteData } from "../server-islands/endpoint.js";
 import { clearContentLayerCache } from "../sync/index.js";
 import { ensureProcessNodeEnv } from "../util.js";
 import { collectPagesData } from "./page-data.js";
@@ -157,7 +158,7 @@ class AstroBuilder {
     await runHookBuildDone({
       settings: this.settings,
       pages: pageNames,
-      routes: Object.values(allPages).flat().map((pageData) => pageData.route),
+      routes: Object.values(allPages).flat().map((pageData) => pageData.route).concat(hasServerIslands ? getServerIslandRouteData(this.settings.config) : []),
       logging: this.logger
     });
     if (this.logger.level && levels[this.logger.level()] <= levels["info"]) {

package/dist/core/build/static-build.js

@@ -272,7 +272,7 @@ async function cleanServerOutput(opts, ssrOutputChunkNames, internals) {
       files.map(async (filename) => {
         const url = new URL(filename, out);
         const map = new URL(url + ".map");
-        await Promise.all([fs.promises.rm(url), fs.promises.rm(new URL(map)).catch((e) => {
+        await Promise.all([fs.promises.rm(url), fs.promises.rm(map).catch(() => {
         })]);
       })
     );

package/dist/core/config/schema.d.ts

@@ -1,5 +1,5 @@
-import type { ShikiConfig, RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype } from '@astrojs/markdown-remark';
 import type { OutgoingHttpHeaders } from 'node:http';
+import type { ShikiConfig, RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype } from '@astrojs/markdown-remark';
 import { z } from 'zod';
 import type { ViteUserConfig } from '../../types/public/config.js';
 interface ComplexifyUnionObj {
@@ -449,34 +449,43 @@ export declare const AstroConfigSchema: z.ZodObject<{
         checkOrigin?: boolean | undefined;
     }>>>;
     env: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
-            context: z.ZodLiteral<"client">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodEffects<z.ZodType<{
             context: "client";
             access: "public";
-        }, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
+            context: "server";
+            access: "secret";
+        }, z.ZodTypeDef, {
             context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
             context: "server";
             access: "public";
-        }, {
+        } | {
             context: "server";
+            access: "secret";
+        }>, {
+            context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"secret">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
         }, {
+            context: "client";
+            access: "public";
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
-        }>]>, z.ZodUnion<[z.ZodObject<{
+        }>, z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"string">;
             optional: z.ZodOptional<z.ZodBoolean>;
             default: z.ZodOptional<z.ZodString>;
@@ -1507,34 +1516,43 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         checkOrigin?: boolean | undefined;
     }>>>;
     env: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
-            context: z.ZodLiteral<"client">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodEffects<z.ZodType<{
             context: "client";
             access: "public";
-        }, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
+            context: "server";
+            access: "secret";
+        }, z.ZodTypeDef, {
             context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
             context: "server";
             access: "public";
-        }, {
+        } | {
             context: "server";
+            access: "secret";
+        }>, {
+            context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"secret">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
         }, {
+            context: "client";
+            access: "public";
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
-        }>]>, z.ZodUnion<[z.ZodObject<{
+        }>, z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"string">;
             optional: z.ZodOptional<z.ZodBoolean>;
             default: z.ZodOptional<z.ZodString>;

package/dist/core/config/schema.js

@@ -1,7 +1,7 @@
-import { markdownConfigDefaults } from "@astrojs/markdown-remark";
-import { bundledThemes } from "shiki";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { markdownConfigDefaults } from "@astrojs/markdown-remark";
+import { bundledThemes } from "shiki";
 import { z } from "zod";
 import { EnvSchema } from "../../env/schema.js";
 import { appendForwardSlash, prependForwardSlash, removeTrailingForwardSlash } from "../path.js";

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.1.2";
+const ASTRO_VERSION = "5.1.4";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/dev.js

@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "5.1.2";
+  const currentVersion = "5.1.4";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -50,23 +50,6 @@ async function dev(inlineConfig) {
     } catch {
     }
   }
-  const devServerAddressInfo = await startContainer(restart.container);
-  logger.info(
-    "SKIP_FORMAT",
-    msg.serverStart({
-      startupTime: performance.now() - devStart,
-      resolvedUrls: restart.container.viteServer.resolvedUrls || { local: [], network: [] },
-      host: restart.container.settings.config.server.host,
-      base: restart.container.settings.config.base
-    })
-  );
-  if (isPrerelease) {
-    logger.warn("SKIP_FORMAT", msg.prerelease({ currentVersion }));
-  }
-  if (restart.container.viteServer.config.server?.fs?.strict === false) {
-    logger.warn("SKIP_FORMAT", msg.fsStrictWarning());
-  }
-  await attachContentServerListeners(restart.container);
   let store;
   try {
     const dataStoreFile = getDataStoreFile(restart.container.settings, true);
@@ -79,6 +62,7 @@ async function dev(inlineConfig) {
   if (!store) {
     store = new MutableDataStore();
   }
+  await attachContentServerListeners(restart.container);
   const config = globalContentConfigObserver.get();
   if (config.status === "error") {
     logger.error("content", config.error.message);
@@ -92,6 +76,24 @@ async function dev(inlineConfig) {
     });
     contentLayer.watchContentConfig();
     await contentLayer.sync();
+  } else {
+    logger.warn("content", "Content config not loaded");
+  }
+  const devServerAddressInfo = await startContainer(restart.container);
+  logger.info(
+    "SKIP_FORMAT",
+    msg.serverStart({
+      startupTime: performance.now() - devStart,
+      resolvedUrls: restart.container.viteServer.resolvedUrls || { local: [], network: [] },
+      host: restart.container.settings.config.server.host,
+      base: restart.container.settings.config.base
+    })
+  );
+  if (isPrerelease) {
+    logger.warn("SKIP_FORMAT", msg.prerelease({ currentVersion }));
+  }
+  if (restart.container.viteServer.config.server?.fs?.strict === false) {
+    logger.warn("SKIP_FORMAT", msg.fsStrictWarning());
   }
   logger.info(null, green("watching for file changes..."));
   return {