astro 7.1.6 → 7.2.1

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

@@ -2,7 +2,7 @@ import type { StaticBuildOptions } from '../../core/build/types.js';
 import type { AstroLogger } from '../../core/logger/core.js';
 import type { MapValue } from '../../type-utils.js';
 import type { AstroConfig } from '../../types/public/config.js';
-import type { AssetsGlobalStaticImagesList } from '../types.js';
+import type { AssetsGlobalStaticImagesList, SerializedStaticImage } from '../types.js';
 type AssetEnv = {
     logger: AstroLogger;
     isSSR: boolean;
@@ -20,4 +20,11 @@ type AssetEnv = {
 export declare function prepareAssetsGenerationEnv(options: StaticBuildOptions, totalCount: number): Promise<AssetEnv>;
 export declare function generateImagesForPath(originalFilePath: string, transformsAndPath: MapValue<AssetsGlobalStaticImagesList>, env: AssetEnv): Promise<void>;
 export declare function getStaticImageList(): AssetsGlobalStaticImagesList;
+/**
+ * Replay transforms attributed to a skipped page back into the global list, so
+ * the asset pipeline emits its optimized images even though the page was not
+ * rendered this build. Existing transforms (already added by a rendered page
+ * that shares the image) are left untouched.
+ */
+export declare function restoreStaticImages(images: SerializedStaticImage[]): void;
 export {};

package/dist/assets/build/generate.js

@@ -233,6 +233,25 @@ function getStaticImageList() {
   }
   return globalThis.astroAsset.staticImages;
 }
+function restoreStaticImages(images) {
+  if (!globalThis.astroAsset) {
+    globalThis.astroAsset = { referencedImages: /* @__PURE__ */ new Set() };
+  }
+  const staticImages = globalThis.astroAsset.staticImages ??= /* @__PURE__ */ new Map();
+  for (const image of images) {
+    let transformsForPath = staticImages.get(image.originalPath);
+    if (!transformsForPath) {
+      transformsForPath = { originalSrcPath: image.originalSrcPath, transforms: /* @__PURE__ */ new Map() };
+      staticImages.set(image.originalPath, transformsForPath);
+    }
+    if (!transformsForPath.transforms.has(image.hash)) {
+      transformsForPath.transforms.set(image.hash, {
+        finalPath: image.finalPath,
+        transform: image.transform
+      });
+    }
+  }
+}
 async function loadImage(path, env) {
   if (isRemotePath(path)) {
     return await loadRemoteImage(path, void 0, env.imageConfig);
@@ -245,5 +264,6 @@ async function loadImage(path, env) {
 export {
   generateImagesForPath,
   getStaticImageList,
-  prepareAssetsGenerationEnv
+  prepareAssetsGenerationEnv,
+  restoreStaticImages
 };

package/dist/assets/fonts/providers/index.js

@@ -94,8 +94,18 @@ function googleicons() {
     async init(context) {
       initializedProvider = await provider(context);
     },
-    async resolveFont({ familyName, ...rest }) {
-      return await initializedProvider?.resolveFont(familyName, rest);
+    async resolveFont({ familyName, options, ...rest }) {
+      const patchedOptions = options?.experimental?.glyphs && options.experimental.glyphs.length > 1 ? {
+        ...options,
+        experimental: {
+          ...options.experimental,
+          glyphs: [options.experimental.glyphs.join(",")]
+        }
+      } : options;
+      return await initializedProvider?.resolveFont(familyName, {
+        options: patchedOptions,
+        ...rest
+      });
     },
     async listFonts() {
       return await initializedProvider?.listFonts?.();

package/dist/assets/types.d.ts

@@ -14,6 +14,19 @@ export type AssetsGlobalStaticImagesList = Map<string, {
         transform: ImageTransform;
     }>;
 }>;
+/**
+ * A single image transform flattened for persistence in the incremental build
+ * cache. `AssetsGlobalStaticImagesList` nests transforms under their original
+ * path; this carries the original path and transform hash inline so a skipped
+ * page's transforms can be replayed into the global list without a re-render.
+ */
+export interface SerializedStaticImage {
+    originalPath: string;
+    hash: string;
+    finalPath: string;
+    originalSrcPath: string | undefined;
+    transform: ImageTransform;
+}
 declare global {
     var astroAsset: {
         imageService?: ImageService;

package/dist/assets/utils/resolveImports.d.ts

@@ -6,4 +6,3 @@
  * @returns A module id of the image that can be resolved by Vite, or undefined if it is not a local image
  */
 export declare function imageSrcToImportId(imageSrc: string, filePath?: string): string | undefined;
-export declare const importIdToSymbolName: (importId: string) => string;

package/dist/assets/utils/resolveImports.js

@@ -1,6 +1,5 @@
 import { isRemotePath, removeBase } from "@astrojs/internal-helpers/path";
 import { CONTENT_IMAGE_FLAG, IMAGE_IMPORT_PREFIX } from "../../content/consts.js";
-import { shorthash } from "../../runtime/server/shorthash.js";
 import { VALID_INPUT_FORMATS } from "../consts.js";
 function imageSrcToImportId(imageSrc, filePath) {
   imageSrc = removeBase(imageSrc, IMAGE_IMPORT_PREFIX);
@@ -17,8 +16,6 @@ function imageSrcToImportId(imageSrc, filePath) {
   }
   return `${imageSrc}?${params.toString()}`;
 }
-const importIdToSymbolName = (importId) => `__ASTRO_IMAGE_IMPORT_${shorthash(importId)}`;
 export {
-  imageSrcToImportId,
-  importIdToSymbolName
+  imageSrcToImportId
 };

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

@@ -9,6 +9,7 @@ import {
   removeBase,
   removeQueryString
 } from "../core/path.js";
+import { recordStaticImage } from "../core/build/incremental-image-collector.js";
 import { normalizePath } from "../core/viteUtils.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { isAstroServerEnvironment } from "../environments.js";
@@ -72,6 +73,13 @@ const addStaticImageFactory = (settings) => {
         transform: options
       });
     }
+    recordStaticImage({
+      originalPath: finalOriginalPath,
+      hash,
+      finalPath: finalFilePath,
+      originalSrcPath: originalFSPath,
+      transform: options
+    });
     const url = createPlaceholderURL(
       settings.config.build.assetsPrefix ? encodeURI(joinPaths(assetPrefix, finalFilePath)) : encodeURI(prependForwardSlash(joinPaths(settings.config.base, finalFilePath)))
     );

package/dist/cli/add/index.js

@@ -627,7 +627,7 @@ async function tryToInstallIntegrations({
     cwd,
     // Include the `install-metadata` strategy to have the package manager that's
     // used for installation take precedence
-    strategies: ["install-metadata", "lockfile", "packageManager-field"]
+    strategies: ["install-metadata", "lockfile", "packageManager-field", "devEngines-field"]
   });
   logger.debug("add", `package manager: "${packageManager?.name}"`);
   if (!packageManager) return "none";

package/dist/cli/agent.d.ts

@@ -0,0 +1 @@
+export declare function isRunByAgent(): boolean;

package/dist/cli/agent.js

@@ -0,0 +1,11 @@
+import { detectAgenticEnvironment } from "am-i-vibing";
+function isRunByAgent() {
+  try {
+    return detectAgenticEnvironment().type === "agent";
+  } catch {
+    return false;
+  }
+}
+export {
+  isRunByAgent
+};

package/dist/cli/dev/background.d.ts

@@ -1,21 +1,8 @@
 import type { AstroLogger } from '../../core/logger/core.js';
 import type { Flags } from '../flags.js';
-import { type LockFileData } from '../../core/dev/lockfile.js';
-export interface BackgroundResult {
-    pid: number;
-    url: string;
-    existing?: boolean;
-}
-export interface BackgroundErrorResult {
-    error: string;
-    message: string;
-}
-export declare function formatBackgroundOutput(result: BackgroundResult | BackgroundErrorResult): string;
-/**
- * Build the human-readable message shown when a background dev server is running.
- * Lists every network address (when `--host` exposed any) so the output matches
- * the foreground dev server, then appends the management command hints.
- */
+import type { LockFileData } from '../../core/dev/lockfile.js';
+import { formatBackgroundOutput, type BackgroundErrorResult, type BackgroundResult } from '../server.js';
+export { formatBackgroundOutput, type BackgroundErrorResult, type BackgroundResult };
 export declare function formatServerRunningMessage(data: LockFileData, { existing }?: {
     existing?: boolean;
 }): string;

package/dist/cli/dev/background.js

@@ -1,103 +1,17 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, openSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import {
-  checkExistingServer,
-  getLogFileURL,
-  readLockFile,
-  removeLockFile,
-  isProcessAlive,
-  killDevServer
-} from "../../core/dev/lockfile.js";
-import { resolveRoot } from "../../core/config/config.js";
-const require2 = createRequire(import.meta.url);
-function formatBackgroundOutput(result) {
-  return JSON.stringify(result);
-}
+  background as startBackgroundServer,
+  devServerCommand,
+  formatBackgroundOutput,
+  formatServerRunningMessage as formatServerMessage
+} from "../server.js";
 function formatServerRunningMessage(data, { existing = false } = {}) {
-  const lines = [
-    `Dev server ${existing ? "already running" : "running"} at ${data.url} (pid ${data.pid})`
-  ];
-  if (data.urls && data.urls.network.length > 0) {
-    lines.push("  Network:");
-    for (const url of data.urls.network) {
-      lines.push(`    ${url}`);
-    }
-  }
-  lines.push("  Stop:   astro dev stop", "  Status: astro dev status", "  Logs:   astro dev logs");
-  return lines.join("\n");
+  return formatServerMessage(data, devServerCommand, { existing });
 }
 async function background({
   flags,
   logger
 }) {
-  const root = pathToFileURL(resolveRoot(flags.root) + "/");
-  const existing = checkExistingServer(root);
-  if (existing && !flags.force) {
-    logger.info("SKIP_FORMAT", formatServerRunningMessage(existing, { existing: true }));
-    return;
-  }
-  if (existing && flags.force) {
-    await killDevServer(root, existing);
-  }
-  const args = ["dev"];
-  if (flags.port) args.push("--port", String(flags.port));
-  if (flags.host != null) {
-    if (typeof flags.host === "string") {
-      args.push("--host", flags.host);
-    } else {
-      args.push("--host");
-    }
-  }
-  if (flags.config) args.push("--config", String(flags.config));
-  if (flags.root) args.push("--root", String(flags.root));
-  if (flags.allowedHosts) args.push("--allowed-hosts", String(flags.allowedHosts));
-  if (flags.json) args.push("--json");
-  const logFileURL = getLogFileURL(root);
-  const logFilePath = fileURLToPath(logFileURL);
-  const dotAstroDir = fileURLToPath(new URL(".astro/", root));
-  if (!existsSync(dotAstroDir)) {
-    mkdirSync(dotAstroDir, { recursive: true });
-  }
-  const logFd = openSync(logFilePath, "w");
-  const rootPath = fileURLToPath(root);
-  const astroBin = resolve(dirname(require2.resolve("astro/package.json")), "bin", "astro.mjs");
-  const child = spawn(process.execPath, [astroBin, ...args], {
-    detached: true,
-    windowsHide: true,
-    stdio: ["ignore", logFd, logFd],
-    cwd: rootPath,
-    env: { ...process.env, ASTRO_DEV_BACKGROUND: "1" }
-  });
-  child.unref();
-  const childPid = child.pid;
-  if (!childPid) {
-    logger.error("SKIP_FORMAT", "Failed to spawn background dev server process.");
-    process.exit(1);
-  }
-  const timeout = 3e4;
-  const deadline = Date.now() + timeout;
-  while (Date.now() < deadline) {
-    if (!isProcessAlive(childPid)) {
-      logger.error("SKIP_FORMAT", "Dev server process exited before becoming ready.");
-      process.exit(1);
-    }
-    const lockData = readLockFile(root);
-    if (lockData && lockData.pid === childPid) {
-      logger.info("SKIP_FORMAT", formatServerRunningMessage(lockData));
-      return;
-    }
-    await new Promise((r) => setTimeout(r, 200));
-  }
-  try {
-    process.kill(childPid, "SIGTERM");
-  } catch {
-  }
-  removeLockFile(root);
-  logger.error("SKIP_FORMAT", `Dev server failed to start within ${timeout / 1e3}s.`);
-  process.exit(1);
+  await startBackgroundServer({ flags, logger, config: devServerCommand });
 }
 export {
   background,

package/dist/cli/dev/index.d.ts

@@ -1,3 +1,4 @@
+import type { ResolvedServerUrls } from 'vite';
 import { type Flags } from '../flags.js';
 interface DevOptions {
     flags: Flags;
@@ -13,6 +14,17 @@ export declare function isIgnoreLock(flags: Flags): boolean;
  * with `--ignore-lock`, or `null` if there's no conflict.
  */
 export declare function getBackgroundIgnoreLockConflict(flags: Flags, wantsBackground: boolean): string | null;
+/**
+ * Pick the URL to record in the lock file.
+ *
+ * Vite only reports a `local` URL for loopback hosts. With `--host <custom-address>` set to a
+ * specific non-loopback address the URL lands in `network` instead and `local` is empty, so
+ * prefer `local` but fall back to `network` rather than reading `undefined`.
+ *
+ * Returns `null` when the server exposed no usable URL, which leaves the (purely bookkeeping)
+ * lock file unwritten instead of taking down an otherwise healthy dev server.
+ */
+export declare function resolveLockFileUrl(resolvedUrls: ResolvedServerUrls): string | null;
 /**
  * `--force` (replace the existing server) and `--ignore-lock` (start alongside it,
  * untracked) express contradictory intent. Returns an error message if both are set,

package/dist/cli/dev/index.js

@@ -1,4 +1,3 @@
-import { detectAgenticEnvironment } from "am-i-vibing";
 import colors from "piccolore";
 import devServer from "../../core/dev/index.js";
 import { pathToFileURL } from "node:url";
@@ -10,14 +9,8 @@ import {
 } from "../../core/dev/lockfile.js";
 import { resolveRoot } from "../../core/config/config.js";
 import { printHelp } from "../../core/messages/runtime.js";
+import { isRunByAgent } from "../agent.js";
 import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
-function isRunByAgent() {
-  try {
-    return detectAgenticEnvironment().type === "agent";
-  } catch {
-    return false;
-  }
-}
 function isIgnoreLock(flags) {
   return flags.ignoreLock === true;
 }
@@ -33,6 +26,17 @@ function getBackgroundIgnoreLockConflict(flags, wantsBackground) {
     "Run the dev server in the foreground to use --ignore-lock."
   ].join("\n");
 }
+function resolveLockFileUrl(resolvedUrls) {
+  const resolved = resolvedUrls.local[0] ?? resolvedUrls.network[0];
+  if (!resolved) {
+    return null;
+  }
+  try {
+    return new URL(resolved).origin;
+  } catch {
+    return null;
+  }
+}
 function getForceIgnoreLockConflict(flags) {
   if (!flags.force) {
     return null;
@@ -155,25 +159,28 @@ Run \`astro dev --help\` to see available commands.`
   }
   const inlineConfig = flagsToAstroInlineConfig(flags);
   const server = await devServer(inlineConfig);
-  const serverUrl = new URL(server.resolvedUrls.local[0]).origin;
-  writeLockFile(root, {
-    pid: process.pid,
-    port: server.address.port,
-    url: serverUrl,
-    urls: server.resolvedUrls,
-    background: !!process.env.ASTRO_DEV_BACKGROUND,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  const originalStop = server.stop.bind(server);
-  server.stop = async () => {
-    removeLockFile(root);
-    await originalStop();
-  };
+  const serverUrl = resolveLockFileUrl(server.resolvedUrls);
+  if (serverUrl) {
+    writeLockFile(root, {
+      pid: process.pid,
+      port: server.address.port,
+      url: serverUrl,
+      urls: server.resolvedUrls,
+      background: !!process.env.ASTRO_DEV_BACKGROUND,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const originalStop = server.stop.bind(server);
+    server.stop = async () => {
+      removeLockFile(root);
+      await originalStop();
+    };
+  }
   return server;
 }
 export {
   dev,
   getBackgroundIgnoreLockConflict,
   getForceIgnoreLockConflict,
-  isIgnoreLock
+  isIgnoreLock,
+  resolveLockFileUrl
 };

package/dist/cli/dev/logs.js

@@ -1,71 +1,9 @@
-import { readFileSync, existsSync, statSync, createReadStream, watch } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { checkExistingServer, getLogFileURL, isProcessAlive } from "../../core/dev/lockfile.js";
-import { resolveRoot } from "../../core/config/config.js";
+import { devServerCommand, logs as serverLogs } from "../server.js";
 async function logs({
   flags,
   logger
 }) {
-  const root = pathToFileURL(resolveRoot(flags.root) + "/");
-  const existing = checkExistingServer(root);
-  if (!existing) {
-    logger.error("SKIP_FORMAT", "No dev server is running.");
-    process.exit(1);
-  }
-  if (!existing.background) {
-    logger.error(
-      "SKIP_FORMAT",
-      "The running dev server was not started with `astro dev --background`. View logs in the terminal where it was started."
-    );
-    process.exit(1);
-  }
-  const logFileURL = getLogFileURL(root);
-  const logFilePath = fileURLToPath(logFileURL);
-  if (!existsSync(logFilePath)) {
-    logger.error("SKIP_FORMAT", "No log file found.");
-    process.exit(1);
-  }
-  const follow = flags.follow || flags.f;
-  if (!follow) {
-    const content = readFileSync(logFilePath, "utf-8");
-    process.stdout.write(content);
-    return;
-  }
-  let offset = statSync(logFilePath).size;
-  if (offset > 0) {
-    const content = readFileSync(logFilePath, "utf-8");
-    process.stdout.write(content);
-  }
-  const watcher = watch(logFilePath, () => {
-    const currentSize = statSync(logFilePath).size;
-    if (currentSize > offset) {
-      const stream = createReadStream(logFilePath, { start: offset, encoding: "utf-8" });
-      stream.on("data", (chunk) => process.stdout.write(chunk));
-      stream.on("end", () => {
-        offset = currentSize;
-      });
-    }
-  });
-  const aliveCheck = setInterval(() => {
-    if (!isProcessAlive(existing.pid)) {
-      const currentSize = statSync(logFilePath).size;
-      if (currentSize > offset) {
-        const remaining = readFileSync(logFilePath, { encoding: "utf-8" }).slice(offset);
-        process.stdout.write(remaining);
-      }
-      watcher.close();
-      clearInterval(aliveCheck);
-    }
-  }, 1e3);
-  const cleanup = () => {
-    watcher.close();
-    clearInterval(aliveCheck);
-    process.exit(0);
-  };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
-  await new Promise(() => {
-  });
+  await serverLogs({ flags, logger, config: devServerCommand });
 }
 export {
   logs

package/dist/cli/dev/status.d.ts

@@ -1,14 +1,7 @@
 import type { AstroLogger } from '../../core/logger/core.js';
 import type { Flags } from '../flags.js';
-export interface StatusResult {
-    running: boolean;
-    pid?: number;
-    url?: string;
-    port?: number;
-    background?: boolean;
-    uptime?: number;
-}
-export declare function formatStatusOutput(result: StatusResult): string;
+import { formatStatusOutput, type StatusResult } from '../server.js';
+export { formatStatusOutput, type StatusResult };
 export declare function status({ flags, logger, }: {
     flags: Flags;
     logger: AstroLogger;

package/dist/cli/dev/status.js

@@ -1,31 +1,13 @@
-import { pathToFileURL } from "node:url";
-import { checkExistingServer } from "../../core/dev/lockfile.js";
-import { resolveRoot } from "../../core/config/config.js";
-function formatStatusOutput(result) {
-  return JSON.stringify(result);
-}
+import {
+  devServerCommand,
+  formatStatusOutput,
+  status as serverStatus
+} from "../server.js";
 async function status({
   flags,
   logger
 }) {
-  const root = pathToFileURL(resolveRoot(flags.root) + "/");
-  const existing = checkExistingServer(root);
-  if (!existing) {
-    logger.info("SKIP_FORMAT", "No dev server is running.");
-    return;
-  }
-  const startedAt = new Date(existing.startedAt).getTime();
-  const uptime = Math.floor((Date.now() - startedAt) / 1e3);
-  const lines = [
-    `Dev server running at ${existing.url} (pid ${existing.pid}, uptime ${uptime}s${existing.background ? ", background" : ""})`
-  ];
-  if (existing.urls && existing.urls.network.length > 0) {
-    lines.push("  Network:");
-    for (const url of existing.urls.network) {
-      lines.push(`    ${url}`);
-    }
-  }
-  logger.info("SKIP_FORMAT", lines.join("\n"));
+  await serverStatus({ flags, logger, config: devServerCommand });
 }
 export {
   formatStatusOutput,

package/dist/cli/dev/stop.d.ts

@@ -1,11 +1,7 @@
 import type { AstroLogger } from '../../core/logger/core.js';
 import type { Flags } from '../flags.js';
-export interface StopResult {
-    stopped: boolean;
-    pid?: number;
-    reason?: string;
-}
-export declare function formatStopOutput(result: StopResult): string;
+import { formatStopOutput, type StopResult } from '../server.js';
+export { formatStopOutput, type StopResult };
 export declare function stop({ flags, logger, }: {
     flags: Flags;
     logger: AstroLogger;

package/dist/cli/dev/stop.js

@@ -1,21 +1,13 @@
-import { pathToFileURL } from "node:url";
-import { checkExistingServer, killDevServer } from "../../core/dev/lockfile.js";
-import { resolveRoot } from "../../core/config/config.js";
-function formatStopOutput(result) {
-  return JSON.stringify(result);
-}
+import {
+  devServerCommand,
+  formatStopOutput,
+  stop as stopServer
+} from "../server.js";
 async function stop({
   flags,
   logger
 }) {
-  const root = pathToFileURL(resolveRoot(flags.root) + "/");
-  const existing = checkExistingServer(root);
-  if (!existing) {
-    logger.info("SKIP_FORMAT", "No dev server is running.");
-    return;
-  }
-  await killDevServer(root, existing);
-  logger.info("SKIP_FORMAT", `Stopped dev server (pid ${existing.pid}).`);
+  await stopServer({ flags, logger, config: devServerCommand });
 }
 export {
   formatStopOutput,

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.1.6";
+  version = "7.2.1";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/cli/install-package.js

@@ -40,7 +40,7 @@ async function installPackage(packageNames, options, logger) {
     cwd,
     // Include the `install-metadata` strategy to have the package manager that's
     // used for installation take precedence
-    strategies: ["install-metadata", "lockfile", "packageManager-field"]
+    strategies: ["install-metadata", "lockfile", "packageManager-field", "devEngines-field"]
   });
   const installCommand = resolveCommand(packageManager?.agent ?? "npm", "add", []);
   if (!installCommand) return false;