astro 7.2.1 → 7.2.2

package/dist/assets/fonts/constants.d.ts

@@ -15,3 +15,11 @@ export declare const FONT_FORMATS: Array<{
 }>;
 export declare const GENERIC_FALLBACK_NAMES: readonly ["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "emoji", "math", "fangsong"];
 export declare const FONTS_TYPES_FILE = "fonts.d.ts";
+/**
+ * Variable name used in the font-file-url-resolver virtual module to hold
+ * the ephemeral font HTTP server address. The incremental build plugin
+ * strips the variable declaration (which contains an OS-assigned port that
+ * changes every build) from the module source before hashing so that the
+ * dependency hash is deterministic across builds.
+ */
+export declare const FONTS_SERVER_ADDRESS_PLACEHOLDER = "__ASTRO_FONTS_SERVER_ADDRESS__";

package/dist/assets/fonts/constants.js

@@ -39,10 +39,12 @@ const GENERIC_FALLBACK_NAMES = [
   "fangsong"
 ];
 const FONTS_TYPES_FILE = "fonts.d.ts";
+const FONTS_SERVER_ADDRESS_PLACEHOLDER = "__ASTRO_FONTS_SERVER_ADDRESS__";
 export {
   ASSETS_DIR,
   CACHE_DIR,
   DEFAULTS,
+  FONTS_SERVER_ADDRESS_PLACEHOLDER,
   FONTS_TYPES_FILE,
   FONT_FORMATS,
   FONT_TYPES,

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

@@ -13,6 +13,7 @@ import {
   ASSETS_DIR,
   CACHE_DIR,
   DEFAULTS,
+  FONTS_SERVER_ADDRESS_PLACEHOLDER,
   RESOLVED_RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID,
   RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
@@ -285,9 +286,10 @@ function fontsPlugin({ settings, sync, logger }) {
           return {
             code: `
 							import { RemoteRuntimeFontFileUrlResolver } from ${JSON.stringify(new URL("./infra/remote-runtime-font-file-url-resolver.js", import.meta.url))};
+							const ${FONTS_SERVER_ADDRESS_PLACEHOLDER} = ${JSON.stringify(serverAddress)};
 							export const runtimeFontFileUrlResolver = new RemoteRuntimeFontFileUrlResolver({
 								urls: new Set(${JSON.stringify(urls)}),
-								address: ${JSON.stringify(serverAddress)},
+								address: ${FONTS_SERVER_ADDRESS_PLACEHOLDER},
 							});
 						`
           };

package/dist/assets/utils/node.js

@@ -36,6 +36,35 @@ async function handleSvgDeduplication(fileData, filename, fileEmitter) {
     return handle;
   }
 }
+const TRANSIENT_ERROR_CODES = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EAGAIN", "EBUSY"]);
+const MAX_CONCURRENT_READS = 200;
+let activeReads = 0;
+const readQueue = [];
+async function readFileWithRetry(url, maxRetries = 5) {
+  if (activeReads >= MAX_CONCURRENT_READS) {
+    await new Promise((resolve) => readQueue.push(resolve));
+  }
+  activeReads++;
+  try {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await fs.readFile(url);
+      } catch (err) {
+        const code = err instanceof Error && "code" in err ? err.code : void 0;
+        if (code && TRANSIENT_ERROR_CODES.has(code) && attempt < maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt));
+          continue;
+        }
+        throw err;
+      }
+    }
+  } finally {
+    activeReads--;
+    if (readQueue.length > 0) {
+      readQueue.shift()();
+    }
+  }
+}
 async function emitImageMetadata(id, fileEmitter) {
   if (!id) {
     return void 0;
@@ -43,9 +72,12 @@ async function emitImageMetadata(id, fileEmitter) {
   const url = pathToFileURL(id);
   let fileData;
   try {
-    fileData = await fs.readFile(url);
-  } catch {
-    return void 0;
+    fileData = await readFileWithRetry(url);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
   }
   const fileMetadata = await imageMetadata(fileData, id);
   const emittedImage = {

package/dist/cli/dev/index.js

@@ -128,7 +128,7 @@ Run \`astro dev --help\` to see available commands.`
   }
   const root = pathToFileURL(resolveRoot(flags.root) + "/");
   if (ignoreLock) {
-    const existingServer2 = checkExistingServer(root);
+    const existingServer2 = await checkExistingServer(root);
     if (existingServer2) {
       logger.info(
         "SKIP_FORMAT",
@@ -141,7 +141,7 @@ Run \`astro dev --help\` to see available commands.`
     const inlineConfig2 = flagsToAstroInlineConfig(flags);
     return await devServer(inlineConfig2);
   }
-  const existingServer = checkExistingServer(root);
+  const existingServer = await checkExistingServer(root);
   if (existingServer) {
     if (flags.force) {
       await killDevServer(root, existingServer);

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "7.2.1";
+  version = "7.2.2";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/cli/preview/index.js

@@ -69,7 +69,7 @@ Run \`astro preview --help\` to see available commands.`
     process.exit(1);
   }
   const root = pathToFileURL(resolveRoot(flags.root) + "/");
-  const existingServer = checkExistingServer(root, "preview");
+  const existingServer = await checkExistingServer(root, "preview");
   if (existingServer) {
     const message = [
       "Another astro preview server is already running.",

package/dist/cli/server.js

@@ -101,7 +101,7 @@ async function background({
   config
 }) {
   const root = getRootURL(flags);
-  const existing = checkExistingServer(root, config.command);
+  const existing = await checkExistingServer(root, config.command);
   if (existing && !flags.force) {
     logger.info("SKIP_FORMAT", formatServerRunningMessage(existing, config, { existing: true }));
     return;
@@ -160,7 +160,7 @@ async function stop({
   config
 }) {
   const root = getRootURL(flags);
-  const existing = checkExistingServer(root, config.command);
+  const existing = await checkExistingServer(root, config.command);
   if (!existing) {
     logger.info("SKIP_FORMAT", `No ${config.command} server is running.`);
     return;
@@ -174,7 +174,7 @@ async function status({
   config
 }) {
   const root = getRootURL(flags);
-  const existing = checkExistingServer(root, config.command);
+  const existing = await checkExistingServer(root, config.command);
   if (!existing) {
     logger.info("SKIP_FORMAT", `No ${config.command} server is running.`);
     return;
@@ -198,7 +198,7 @@ async function logs({
   config
 }) {
   const root = getRootURL(flags);
-  const existing = checkExistingServer(root, config.command);
+  const existing = await checkExistingServer(root, config.command);
   if (!existing) {
     logger.error("SKIP_FORMAT", `No ${config.command} server is running.`);
     process.exit(1);

package/dist/content/content-layer.js

@@ -196,7 +196,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.2.1") {
+    if (previousAstroVersion && previousAstroVersion !== "7.2.2") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -204,8 +204,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.2.1") {
-      this.#store.metaStore().set("astro-version", "7.2.1");
+    if ("7.2.2") {
+      this.#store.metaStore().set("astro-version", "7.2.2");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/loaders/file.js

@@ -2,7 +2,11 @@ import { existsSync, promises as fs } from "node:fs";
 import { fileURLToPath } from "node:url";
 import * as yaml from "js-yaml";
 import * as toml from "smol-toml";
-import { FileGlobNotSupported, FileParserNotFound } from "../../core/errors/errors-data.js";
+import {
+  DuplicateContentEntrySlugError,
+  FileGlobNotSupported,
+  FileParserNotFound
+} from "../../core/errors/errors-data.js";
 import { AstroError } from "../../core/errors/index.js";
 import { posixRelative } from "../utils.js";
 function file(fileName, options) {
@@ -27,7 +31,7 @@ function file(fileName, options) {
       message: FileParserNotFound.message(fileName)
     });
   }
-  async function syncData(filePath, { logger, parseData, store, config }) {
+  async function syncData(filePath, { logger, parseData, store, config, collection }) {
     let data;
     try {
       const contents = await fs.readFile(filePath, "utf-8");
@@ -52,9 +56,20 @@ function file(fileName, options) {
           continue;
         }
         if (idList.has(id)) {
-          logger.warn(
-            `Duplicate id "${id}" found in ${fileName}. Later items with the same id will overwrite earlier ones.`
+          const message = DuplicateContentEntrySlugError.message(
+            collection,
+            id,
+            fileName,
+            fileName
           );
+          if (config.prerenderConflictBehavior === "error") {
+            throw new AstroError({
+              ...DuplicateContentEntrySlugError,
+              message
+            });
+          } else if (config.prerenderConflictBehavior !== "ignore") {
+            logger.warn(message);
+          }
         }
         idList.add(id);
         const parsedData = await parseData({ id, data: rawItem, filePath });

package/dist/content/loaders/glob.js

@@ -5,6 +5,8 @@ import pLimit from "p-limit";
 import colors from "piccolore";
 import picomatch from "picomatch";
 import { glob as tinyglobby } from "tinyglobby";
+import * as AstroErrorData from "../../core/errors/errors-data.js";
+import { AstroError } from "../../core/errors/index.js";
 import { getContentEntryIdAndSlug, posixRelative } from "../utils.js";
 function generateIdDefault({ entry, base, data }, isLegacy) {
   if (data.slug) {
@@ -107,9 +109,20 @@ function glob(globOptions) {
         if (existingEntry && existingEntry.filePath && existingEntry.filePath !== relativePath2) {
           const oldFilePath = new URL(existingEntry.filePath, config.root);
           if (existsSync(oldFilePath)) {
-            logger.warn(
-              `Duplicate id "${id}" found in ${filePath2}. Later items with the same id will overwrite earlier ones.`
+            const message = AstroErrorData.DuplicateContentEntrySlugError.message(
+              collection,
+              id,
+              existingEntry.filePath,
+              relativePath2
             );
+            if (config.prerenderConflictBehavior === "error") {
+              throw new AstroError({
+                ...AstroErrorData.DuplicateContentEntrySlugError,
+                message
+              });
+            } else if (config.prerenderConflictBehavior !== "ignore") {
+              logger.warn(message);
+            }
           }
         }
         if (entryType.getRenderFunction && !globOptions.deferRender) {

package/dist/core/build/generate.js

@@ -222,7 +222,16 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
     if (prerenderer.collectStaticImages) {
       const adapterImages = await prerenderer.collectStaticImages();
       for (const [path, entry] of adapterImages) {
-        staticImageList.set(path, entry);
+        const existing = staticImageList.get(path);
+        if (existing) {
+          for (const [hash, transform] of entry.transforms) {
+            if (!existing.transforms.has(hash)) {
+              existing.transforms.set(hash, transform);
+            }
+          }
+        } else {
+          staticImageList.set(path, entry);
+        }
       }
     }
   } finally {

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

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import { FONTS_SERVER_ADDRESS_PLACEHOLDER } from "../../../assets/fonts/constants.js";
 import { PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
 import { hasContentFlag } from "../../../content/utils.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
@@ -7,29 +8,13 @@ import { rootRelativePath } from "../../viteUtils.js";
 import { moduleIsTopLevelPage } from "../graph.js";
 import { isContentDataIncrementalModule } from "../incremental-metadata.js";
 import { getPageDataByViteID } from "../internal.js";
-function collectTransitiveDeps(graph, rootId) {
-  const deps = /* @__PURE__ */ new Set();
-  const queue = [rootId];
-  while (queue.length > 0) {
-    const current = queue.pop();
-    if (deps.has(current)) continue;
-    const modInfo = graph.getModuleInfo(current);
-    if (isContentDataIncrementalModule(modInfo)) continue;
-    deps.add(current);
-    if (!modInfo) continue;
-    for (const dep of modInfo.importedIds) {
-      if (!deps.has(dep)) queue.push(dep);
-    }
-    for (const dep of modInfo.dynamicallyImportedIds) {
-      if (!deps.has(dep)) queue.push(dep);
-    }
-  }
-  return [...deps].sort();
-}
 const ASSET_PLACEHOLDERS = [
   { token: "__ASTRO_ASSET_IMAGE__", pattern: /__ASTRO_ASSET_IMAGE__([\w$]+)__(?:_(.*?)__)?/g },
   { token: "__VITE_ASSET__", pattern: /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g }
 ];
+const FONTS_ADDRESS_DECLARATION = new RegExp(
+  `(?:const|let|var)\\s+${FONTS_SERVER_ADDRESS_PLACEHOLDER}\\s*=[^;]+;`
+);
 function resolveAssetPlaceholders(graph, code) {
   let resolved = code;
   for (const { token, pattern } of ASSET_PLACEHOLDERS) {
@@ -42,6 +27,9 @@ function resolveAssetPlaceholders(graph, code) {
       }
     });
   }
+  if (resolved.includes(FONTS_SERVER_ADDRESS_PLACEHOLDER)) {
+    resolved = resolved.replace(FONTS_ADDRESS_DECLARATION, "");
+  }
   return resolved;
 }
 function hashModules(graph, sortedIds) {
@@ -57,11 +45,131 @@ function hashModules(graph, sortedIds) {
   }
   return hasher.digest("hex");
 }
-function collectClientEntrypointHashes(graph, entrypointIds, pagesByEntrypoint, hashesByComponent) {
+function createTransitiveGraphCache(graph) {
+  const modules = /* @__PURE__ */ new Map();
+  const dependencies = /* @__PURE__ */ new Map();
+  const excludedModules = /* @__PURE__ */ new Set();
+  const pending = [...graph.getModuleIds()];
+  for (const id of pending) {
+    if (modules.has(id)) continue;
+    const info = graph.getModuleInfo(id);
+    modules.set(id, info);
+    if (isContentDataIncrementalModule(info)) {
+      excludedModules.add(id);
+      continue;
+    }
+    const importedIds = [...info?.importedIds ?? [], ...info?.dynamicallyImportedIds ?? []];
+    dependencies.set(id, importedIds);
+    pending.push(...importedIds);
+  }
+  for (const id of excludedModules) modules.delete(id);
+  for (const [id, importedIds] of dependencies) {
+    dependencies.set(
+      id,
+      importedIds.filter((importedId) => !excludedModules.has(importedId))
+    );
+  }
+  const reverseDependencies = /* @__PURE__ */ new Map();
+  for (const id of modules.keys()) reverseDependencies.set(id, []);
+  for (const [id, importedIds] of dependencies) {
+    for (const importedId of importedIds) reverseDependencies.get(importedId)?.push(id);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const finishOrder = [];
+  for (const rootId of modules.keys()) {
+    if (visited.has(rootId)) continue;
+    visited.add(rootId);
+    const stack = [[rootId, 0]];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const importedIds = dependencies.get(frame[0]) ?? [];
+      if (frame[1] < importedIds.length) {
+        const importedId = importedIds[frame[1]++];
+        if (!visited.has(importedId)) {
+          visited.add(importedId);
+          stack.push([importedId, 0]);
+        }
+      } else {
+        finishOrder.push(frame[0]);
+        stack.pop();
+      }
+    }
+  }
+  const componentByModule = /* @__PURE__ */ new Map();
+  const components = [];
+  for (const rootId of finishOrder.toReversed()) {
+    if (componentByModule.has(rootId)) continue;
+    const componentIndex = components.length;
+    const component = [];
+    const stack = [rootId];
+    componentByModule.set(rootId, componentIndex);
+    while (stack.length > 0) {
+      const id = stack.pop();
+      component.push(id);
+      for (const importerId of reverseDependencies.get(id) ?? []) {
+        if (!componentByModule.has(importerId)) {
+          componentByModule.set(importerId, componentIndex);
+          stack.push(importerId);
+        }
+      }
+    }
+    components.push(component.sort());
+  }
+  const componentDependencies = components.map(() => /* @__PURE__ */ new Set());
+  const componentImporters = components.map(() => /* @__PURE__ */ new Set());
+  for (const [id, importedIds] of dependencies) {
+    const componentIndex = componentByModule.get(id);
+    for (const importedId of importedIds) {
+      const dependencyIndex = componentByModule.get(importedId);
+      if (dependencyIndex === componentIndex) continue;
+      componentDependencies[componentIndex].add(dependencyIndex);
+      componentImporters[dependencyIndex].add(componentIndex);
+    }
+  }
+  const componentHashes = /* @__PURE__ */ new Map();
+  const componentHasServerIsland = /* @__PURE__ */ new Map();
+  const unresolvedDependencies = componentDependencies.map((items) => items.size);
+  const ready = unresolvedDependencies.flatMap((count, index) => count === 0 ? [index] : []);
+  for (const componentIndex of ready) {
+    const hasher = crypto.createHash("sha256");
+    hasher.update(hashModules(graph, components[componentIndex]));
+    const dependencyHashes = [...componentDependencies[componentIndex]].map((dependencyIndex) => componentHashes.get(dependencyIndex)).sort();
+    for (const dependencyHash of dependencyHashes) {
+      hasher.update("\n");
+      hasher.update(dependencyHash);
+    }
+    componentHashes.set(componentIndex, hasher.digest("hex"));
+    componentHasServerIsland.set(
+      componentIndex,
+      components[componentIndex].some(
+        (id) => (modules.get(id)?.meta?.astro?.serverComponents?.length ?? 0) > 0
+      ) || [...componentDependencies[componentIndex]].some(
+        (dependencyIndex) => componentHasServerIsland.get(dependencyIndex)
+      )
+    );
+    for (const importerIndex of componentImporters[componentIndex]) {
+      unresolvedDependencies[importerIndex]--;
+      if (unresolvedDependencies[importerIndex] === 0) ready.push(importerIndex);
+    }
+  }
+  return {
+    hashes: new Map(
+      [...componentByModule].map(([id, componentIndex]) => [
+        id,
+        componentHashes.get(componentIndex)
+      ])
+    ),
+    serverIslandModules: new Set(
+      [...componentByModule].filter(([, componentIndex]) => componentHasServerIsland.get(componentIndex)).map(([id]) => id)
+    )
+  };
+}
+function collectClientEntrypointHashes(transitiveHashes, entrypointIds, pagesByEntrypoint, hashesByComponent) {
   for (const entrypointId of entrypointIds) {
     const pages = pagesByEntrypoint.get(entrypointId);
     if (!pages?.size) continue;
-    const hash = hashModules(graph, collectTransitiveDeps(graph, entrypointId));
+    const hash = transitiveHashes.get(entrypointId);
+    if (!hash) continue;
     for (const pageData of pages) {
       let list = hashesByComponent.get(pageData.component);
       if (!list) {
@@ -75,15 +183,16 @@ function collectClientEntrypointHashes(graph, entrypointIds, pagesByEntrypoint,
 function foldClientDependencies(graph, internals) {
   const baseHashes = internals.pageDependencyHashes;
   if (!baseHashes) return;
+  const { hashes: transitiveHashes } = createTransitiveGraphCache(graph);
   const hashesByComponent = /* @__PURE__ */ new Map();
   collectClientEntrypointHashes(
-    graph,
+    transitiveHashes,
     internals.discoveredClientOnlyComponents.keys(),
     internals.pagesByClientOnly,
     hashesByComponent
   );
   collectClientEntrypointHashes(
-    graph,
+    transitiveHashes,
     internals.discoveredScripts,
     internals.pagesByScriptId,
     hashesByComponent
@@ -98,24 +207,17 @@ function foldClientDependencies(graph, internals) {
     baseHashes.set(component, hasher.digest("hex"));
   }
 }
-function collectContentEntryHashes(graph, root) {
+function collectContentEntryHashes(graph, root, transitiveHashes) {
   const entryHashes = /* @__PURE__ */ new Map();
   for (const id of graph.getModuleIds()) {
     if (!hasContentFlag(id, PROPAGATED_ASSET_FLAG)) continue;
     const renderModuleId = removeQueryString(id);
     const key = rootRelativePath(root, renderModuleId, false);
-    const deps = collectTransitiveDeps(graph, renderModuleId);
-    entryHashes.set(key, hashModules(graph, deps));
+    const hash = transitiveHashes.get(renderModuleId);
+    if (hash) entryHashes.set(key, hash);
   }
   return entryHashes;
 }
-function pageContainsServerIsland(graph, ids) {
-  for (const id of ids) {
-    const serverComponents = graph.getModuleInfo(id)?.meta?.astro?.serverComponents;
-    if (serverComponents?.length) return true;
-  }
-  return false;
-}
 function pluginIncremental(internals, root) {
   return {
     name: "@astro/plugin-incremental",
@@ -127,6 +229,7 @@ function pluginIncremental(internals, root) {
         foldClientDependencies(this, internals);
         return;
       }
+      const transitiveGraph = createTransitiveGraphCache(this);
       const hashes = /* @__PURE__ */ new Map();
       const serverIslandComponents = /* @__PURE__ */ new Set();
       for (const id of this.getModuleIds()) {
@@ -135,14 +238,19 @@ function pluginIncremental(internals, root) {
         if (!moduleIsTopLevelPage(info)) continue;
         const pageData = getPageDataByViteID(internals, info.id);
         if (!pageData) continue;
-        const deps = collectTransitiveDeps(this, info.id);
-        hashes.set(pageData.component, hashModules(this, deps));
-        if (pageContainsServerIsland(this, deps)) {
+        const hash = transitiveGraph.hashes.get(info.id);
+        if (!hash) continue;
+        hashes.set(pageData.component, hash);
+        if (transitiveGraph.serverIslandModules.has(info.id)) {
           serverIslandComponents.add(pageData.component);
         }
       }
       internals.pageDependencyHashes = hashes;
-      internals.contentEntryRenderHashes = collectContentEntryHashes(this, root);
+      internals.contentEntryRenderHashes = collectContentEntryHashes(
+        this,
+        root,
+        transitiveGraph.hashes
+      );
       internals.serverIslandPageComponents = serverIslandComponents;
     }
   };

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.2.1";
+const ASTRO_VERSION = "7.2.2";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";

package/dist/core/dev/dev.js

@@ -26,7 +26,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "7.2.1";
+  const currentVersion = "7.2.2";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/dev/lockfile.d.ts

@@ -32,6 +32,22 @@ export declare function serializeLockFile(data: LockFileData): string;
  * Signal 0 does not kill the process — it only checks whether the process exists.
  */
 export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Check whether a process command points to the Astro CLI.
+ */
+export declare function isAstroCommand(command: string): boolean;
+interface ProcessInfo {
+    pid: number;
+    cmd?: string;
+}
+type ProcessLookup = (by: 'pid', value: number, options: {
+    logLevel: 'error';
+}) => Promise<ProcessInfo[]>;
+/**
+ * Check whether the live process recorded in a lock file is still Astro.
+ * If the command cannot be inspected, keep the existing PID-only behavior.
+ */
+export declare function isLockFileProcessAlive(data: LockFileData, find?: ProcessLookup): Promise<boolean>;
 /**
  * Read the lock file from disk. Returns null if it doesn't exist or is invalid.
  */
@@ -58,8 +74,9 @@ export declare function evaluateExistingServer(data: LockFileData | null, alive:
  */
 export declare function killDevServer(root: URL, data: LockFileData): Promise<void>;
 /**
- * Check for an existing server by reading the lock file and checking process liveness.
+ * Check for an existing server by reading the lock file and checking process identity.
  * Automatically cleans up stale lock files.
  * Returns the server info if a live server is found, null otherwise.
  */
-export declare function checkExistingServer(root: URL, command?: ServerCommand): LockFileData | null;
+export declare function checkExistingServer(root: URL, command?: ServerCommand): Promise<LockFileData | null>;
+export {};

package/dist/core/dev/lockfile.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import findProcess from "find-process";
 const GRACEFUL_SHUTDOWN_TIMEOUT = 5e3;
 function getLockFileURL(root, command = "dev") {
   return new URL(`.astro/${command}.json`, root);
@@ -42,6 +43,23 @@ function isProcessAlive(pid) {
     return false;
   }
 }
+const ASTRO_COMMAND_PATTERN = /(?:^|[\\/\s"'])(?:astro[\\/]bin[\\/]astro\.mjs|\.bin[\\/]astro(?:\.cmd)?)(?=$|[\s"'])/i;
+function isAstroCommand(command) {
+  return ASTRO_COMMAND_PATTERN.test(command);
+}
+async function isLockFileProcessAlive(data, find = findProcess) {
+  if (!isProcessAlive(data.pid)) {
+    return false;
+  }
+  try {
+    const processInfo = (await find("pid", data.pid, { logLevel: "error" })).find(
+      ({ pid }) => pid === data.pid
+    );
+    return processInfo?.cmd === void 0 || isAstroCommand(processInfo.cmd);
+  } catch {
+    return true;
+  }
+}
 function readLockFile(root, command = "dev") {
   const lockFileURL = getLockFileURL(root, command);
   try {
@@ -98,9 +116,12 @@ async function killDevServer(root, data) {
   }
   removeLockFile(root);
 }
-function checkExistingServer(root, command = "dev") {
+async function checkExistingServer(root, command = "dev") {
   const data = readLockFile(root, command);
-  const result = evaluateExistingServer(data, data !== null && isProcessAlive(data.pid));
+  const result = evaluateExistingServer(
+    data,
+    data !== null && await isLockFileProcessAlive(data)
+  );
   if (result === null) {
     return null;
   }
@@ -115,6 +136,8 @@ export {
   checkExistingServer,
   evaluateExistingServer,
   getLogFileURL,
+  isAstroCommand,
+  isLockFileProcessAlive,
   isProcessAlive,
   killDevServer,
   parseLockFile,

package/dist/core/messages/runtime.js

@@ -270,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.2.1"}`
+        `v${"7.2.2"}`
       )} ${headline}`
     );
   }

package/dist/core/util.js

@@ -47,8 +47,8 @@ function resolvePages(config) {
   return new URL("./pages", config.srcDir);
 }
 function isInPagesDir(file, config) {
-  const pagesDir = resolvePages(config);
-  return file.toString().startsWith(pagesDir.toString());
+  const pagesDir = `${resolvePages(config).toString()}/`;
+  return file.toString().startsWith(pagesDir);
 }
 function isInjectedRoute(file, settings) {
   let fileURL = file.toString();

package/dist/vite-plugin-css/index.js

@@ -76,7 +76,7 @@ function astroDevCssPlugin({
         server = viteServer;
       },
       applyToEnvironment(env) {
-        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+        return command === "dev" && env.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
       },
       resolveId: {
         filter: {
@@ -163,7 +163,7 @@ function astroDevCssPlugin({
     {
       name: MODULE_DEV_CSS_ALL,
       applyToEnvironment(env) {
-        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+        return command === "dev" && env.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
       },
       resolveId: {
         filter: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "7.2.1",
+  "version": "7.2.2",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -112,6 +112,7 @@
     "dset": "^3.1.4",
     "es-module-lexer": "^2.0.0",
     "esbuild": "^0.28.0",
+    "find-process": "^2.1.1",
     "flattie": "^1.1.1",
     "fontace": "~0.4.1",
     "get-tsconfig": "5.0.0-beta.4",
@@ -145,9 +146,9 @@
     "xxhash-wasm": "^1.1.0",
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6",
-    "@astrojs/internal-helpers": "0.10.2",
+    "@astrojs/telemetry": "3.3.3",
     "@astrojs/markdown-satteri": "0.3.5",
-    "@astrojs/telemetry": "3.3.3"
+    "@astrojs/internal-helpers": "0.10.2"
   },
   "optionalDependencies": {
     "sharp": "^0.34.0 || ^0.35.0"
@@ -185,8 +186,8 @@
     "typescript": "^6.0.3",
     "undici": "^7.22.0",
     "vitest": "^4.1.0",
-    "@astrojs/check": "0.9.10",
     "@astrojs/markdown-remark": "7.2.2",
+    "@astrojs/check": "0.9.10",
     "astro-scripts": "0.0.14"
   },
   "engines": {