astro 7.2.1 → 7.2.3

package/dist/actions/handler.d.ts

@@ -17,16 +17,10 @@ import type { FetchState } from '../core/fetch/fetch-state.js';
  * page dispatch. That placement preserves the existing behavior where
  * user middleware sees action requests and response finalization (cookies,
  * sessions, etc.) runs around the action response.
+ *
+ * Expects the APIContext that is already being used by the render pipeline.
+ * Returns a `Response` when the action fully handles the request (RPC),
+ * or `undefined` when the caller should continue processing the request
+ * (form actions or non-action requests).
  */
-export declare class ActionHandler {
-    #private;
-    /**
-     * Run action handling for the current request. Expects the APIContext
-     * that is already being used by the render pipeline.
-     *
-     * Returns a `Response` when the action fully handles the request (RPC),
-     * or `undefined` when the caller should continue processing the
-     * request (form actions or non-action requests).
-     */
-    handle(apiContext: APIContext, state: FetchState): Promise<Response | undefined> | undefined;
-}
+export declare function handleAction(apiContext: APIContext, state: FetchState): Promise<Response | undefined> | undefined;

package/dist/actions/handler.js

@@ -2,51 +2,41 @@ import {
   createCrossOriginForbiddenResponse,
   isForbiddenCrossOriginRequest
 } from "../core/app/origin-check.js";
-import { PipelineFeatures } from "../core/base-pipeline.js";
+import { markFeatureUsed, FetchFeatures } from "../core/fetch/features.js";
 import { getActionContext, serializeActionResult } from "./runtime/server.js";
-class ActionHandler {
-  /**
-   * Run action handling for the current request. Expects the APIContext
-   * that is already being used by the render pipeline.
-   *
-   * Returns a `Response` when the action fully handles the request (RPC),
-   * or `undefined` when the caller should continue processing the
-   * request (form actions or non-action requests).
-   */
-  handle(apiContext, state) {
-    state.pipeline.usedFeatures |= PipelineFeatures.actions;
-    if (apiContext.isPrerendered) {
-      return void 0;
-    }
-    const { action, setActionResult } = getActionContext(apiContext);
-    if (!action) {
-      return void 0;
-    }
-    if (state.pipeline.manifest.checkOrigin && isForbiddenCrossOriginRequest(apiContext.request, apiContext.url, apiContext.isPrerendered)) {
-      return Promise.resolve(createCrossOriginForbiddenResponse(apiContext.request));
-    }
-    return this.#executeAction(action, setActionResult);
+function handleAction(apiContext, state) {
+  markFeatureUsed(state.manifest, FetchFeatures.actions);
+  if (apiContext.isPrerendered) {
+    return void 0;
   }
-  async #executeAction(action, setActionResult) {
-    const actionResult = await action.handler();
-    const serialized = serializeActionResult(actionResult);
-    if (action.calledFrom === "rpc") {
-      if (serialized.type === "empty") {
-        return new Response(null, {
-          status: serialized.status
-        });
-      }
-      return new Response(serialized.body, {
-        status: serialized.status,
-        headers: {
-          "Content-Type": serialized.contentType
-        }
+  const { action, setActionResult } = getActionContext(apiContext);
+  if (!action) {
+    return void 0;
+  }
+  if (state.manifest.checkOrigin && isForbiddenCrossOriginRequest(apiContext.request, apiContext.url, apiContext.isPrerendered)) {
+    return Promise.resolve(createCrossOriginForbiddenResponse(apiContext.request));
+  }
+  return executeAction(action, setActionResult);
+}
+async function executeAction(action, setActionResult) {
+  const actionResult = await action.handler();
+  const serialized = serializeActionResult(actionResult);
+  if (action.calledFrom === "rpc") {
+    if (serialized.type === "empty") {
+      return new Response(null, {
+        status: serialized.status
       });
     }
-    setActionResult(action.name, serialized);
-    return void 0;
+    return new Response(serialized.body, {
+      status: serialized.status,
+      headers: {
+        "Content-Type": serialized.contentType
+      }
+    });
   }
+  setActionResult(action.name, serialized);
+  return void 0;
 }
 export {
-  ActionHandler
+  handleAction
 };

package/dist/actions/load.d.ts

@@ -0,0 +1,12 @@
+import type { $ZodType } from 'zod/v4/core';
+import type { SSRActions, SSRManifest } from '../types/public/internal.js';
+import type { ActionAccept, ActionClient } from './runtime/types.js';
+/** Resolves the actions module from the manifest (a no-op module when none). */
+export declare function getActions(manifest: SSRManifest): Promise<SSRActions>;
+/**
+ * Clears the cached actions so they are re-resolved on the next request.
+ * Called via HMR when action files change during development.
+ */
+export declare function clearActions(manifest: SSRManifest): void;
+/** Looks up a single action handler by its dot-separated path. */
+export declare function getAction(manifest: SSRManifest, path: string): Promise<ActionClient<unknown, ActionAccept, $ZodType>>;

package/dist/actions/load.js

@@ -0,0 +1,55 @@
+import { FORBIDDEN_PATH_KEYS } from "@astrojs/internal-helpers/object";
+import { ActionNotFoundError } from "../core/errors/errors-data.js";
+import { AstroError } from "../core/errors/index.js";
+import { createAsyncManifestMemo } from "../core/manifest/memo.js";
+import { NOOP_ACTIONS_MOD } from "./noop-actions.js";
+const actionsMemo = createAsyncManifestMemo(
+  async (manifest) => manifest.actions ? await manifest.actions() : NOOP_ACTIONS_MOD
+);
+function getActions(manifest) {
+  return actionsMemo.get(manifest);
+}
+function clearActions(manifest) {
+  actionsMemo.invalidate(manifest);
+}
+async function getAction(manifest, path) {
+  const pathKeys = path.split(".").map((key) => decodeURIComponent(key));
+  let { server } = await getActions(manifest);
+  if (!server || !(typeof server === "object")) {
+    throw new TypeError(
+      `Expected \`server\` export in actions file to be an object. Received ${typeof server}.`
+    );
+  }
+  for (const key of pathKeys) {
+    if (typeof server === "function") {
+      throw new AstroError({
+        ...ActionNotFoundError,
+        message: ActionNotFoundError.message(pathKeys.join("."))
+      });
+    }
+    if (FORBIDDEN_PATH_KEYS.has(key)) {
+      throw new AstroError({
+        ...ActionNotFoundError,
+        message: ActionNotFoundError.message(pathKeys.join("."))
+      });
+    }
+    if (!Object.hasOwn(server, key)) {
+      throw new AstroError({
+        ...ActionNotFoundError,
+        message: ActionNotFoundError.message(pathKeys.join("."))
+      });
+    }
+    server = server[key];
+  }
+  if (typeof server !== "function") {
+    throw new TypeError(
+      `Expected handler for action ${pathKeys.join(".")} to be a function. Received ${typeof server}.`
+    );
+  }
+  return server;
+}
+export {
+  clearActions,
+  getAction,
+  getActions
+};

package/dist/actions/runtime/entrypoints/server.js

@@ -1,6 +1,7 @@
-import { pipelineSymbol } from "../../../core/constants.js";
+import { fetchStateSymbol } from "../../../core/constants.js";
 import { ActionCalledFromServerError } from "../../../core/errors/errors-data.js";
 import { AstroError } from "../../../core/errors/errors.js";
+import { getAction } from "../../load.js";
 import { createGetActionPath, createActionsProxy } from "../client.js";
 import { shouldAppendTrailingSlash } from "virtual:astro:actions/options";
 import { ACTION_QUERY_PARAMS } from "../../consts.js";
@@ -12,11 +13,11 @@ const getActionPath = createGetActionPath({
 });
 const actions = createActionsProxy({
   handleAction: async (param, path, context) => {
-    const pipeline = context ? Reflect.get(context, pipelineSymbol) : void 0;
-    if (!pipeline) {
+    const state = context ? Reflect.get(context, fetchStateSymbol) : void 0;
+    if (!state) {
       throw new AstroError(ActionCalledFromServerError);
     }
-    const action = await pipeline.getAction(path);
+    const action = await getAction(state.manifest, path);
     if (!action) throw new Error(`Action not found: ${path}`);
     return action.bind(context)(param);
   }

package/dist/actions/runtime/server.js

@@ -1,7 +1,9 @@
 import { stringify as devalueStringify } from "devalue";
 import * as z from "zod/v4/core";
 import { shouldAppendForwardSlash } from "../../core/build/util.js";
-import { pipelineSymbol, REDIRECT_STATUS_CODES } from "../../core/constants.js";
+import { REDIRECT_STATUS_CODES } from "../../core/constants.js";
+import { getFetchStateFromAPIContext } from "../../core/fetch/fetch-state.js";
+import { getAction } from "../load.js";
 import {
   ActionCalledFromServerError,
   ActionNotFoundError,
@@ -86,21 +88,21 @@ function getActionContext(context) {
       calledFrom: callerInfo.from,
       name: callerInfo.name,
       handler: async () => {
-        const pipeline = Reflect.get(context, pipelineSymbol);
+        const { manifest } = getFetchStateFromAPIContext(context);
         const callerInfoName = shouldAppendForwardSlash(
-          pipeline.manifest.trailingSlash,
-          pipeline.manifest.buildFormat
+          manifest.trailingSlash,
+          manifest.buildFormat
         ) ? removeTrailingForwardSlash(callerInfo.name) : callerInfo.name;
         let baseAction;
         try {
-          baseAction = await pipeline.getAction(callerInfoName);
+          baseAction = await getAction(manifest, callerInfoName);
         } catch (error) {
           if (error instanceof Error && "name" in error && typeof error.name === "string" && error.name === ActionNotFoundError.name) {
             return { data: void 0, error: new ActionError({ code: "NOT_FOUND" }) };
           }
           throw error;
         }
-        const bodySizeLimit = pipeline.manifest.actionBodySizeLimit;
+        const bodySizeLimit = manifest.actionBodySizeLimit;
         let input;
         try {
           input = await parseRequestBody(context.request, bodySizeLimit);

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

@@ -26,7 +26,7 @@ declare function npm(options?: Omit<NpmProviderOptions, 'root' | 'readFile'>): F
  * - [Google](https://docs.astro.build/en/reference/font-provider-reference/#google)
  * - [Google Icons](https://docs.astro.build/en/reference/font-provider-reference/#google-icons)
  * - [Local](https://docs.astro.build/en/reference/font-provider-reference/#local)
- * - [NPM](TODO:)
+ * - [NPM](https://docs.astro.build/en/reference/font-provider-reference/#npm)
  */
 export declare const fontProviders: {
     adobe: typeof adobe;

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

@@ -94,18 +94,8 @@ function googleicons() {
     async init(context) {
       initializedProvider = await provider(context);
     },
-    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 resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
     },
     async listFonts() {
       return await initializedProvider?.listFonts?.();

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.3";
 }
 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/container/environment.d.ts

@@ -0,0 +1,20 @@
+import type { RouteData, SSRLoadedRenderer, SSRResult } from '../types/public/internal.js';
+import type { SinglePageBuiltModule } from '../core/build/types.js';
+import type { RenderEnvironment } from '../core/environment/index.js';
+export interface ContainerEnvironmentOptions {
+    /**
+     * The route → module interner. Created by `experimental_AstroContainer`'s
+     * constructor and shared with its `insertRoute` writes; this record owns
+     * the lookups.
+     */
+    interner: WeakMap<RouteData, SinglePageBuiltModule>;
+    resolve: SSRResult['resolve'];
+    renderers: SSRLoadedRenderer[];
+    streaming: boolean;
+}
+/**
+ * The container environment. Registered by `experimental_AstroContainer`'s
+ * constructor on its fabricated manifest — the container never touches the
+ * ambient manifest, so multiple containers in one process stay isolated.
+ */
+export declare function createContainerEnvironment({ interner, resolve, renderers, streaming, }: ContainerEnvironmentOptions): RenderEnvironment;

package/dist/container/environment.js

@@ -0,0 +1,106 @@
+import { RedirectSinglePageBuiltModule } from "../core/redirects/index.js";
+import {
+  createModuleScriptElement,
+  createStylesheetElementSet
+} from "../core/render/ssr-element.js";
+import { getDefaultRoutes } from "../core/routing/default.js";
+import { findRouteToRewrite } from "../core/routing/rewrite.js";
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  if (route.type === "redirect") {
+    return RedirectSinglePageBuiltModule;
+  } else {
+    if (manifest.pageMap) {
+      const importComponentInstance = manifest.pageMap.get(route.component);
+      if (!importComponentInstance) {
+        throw new Error(
+          `Unexpectedly unable to find a component instance for route ${route.route}`
+        );
+      }
+      return await importComponentInstance();
+    } else if (manifest.pageModule) {
+      return manifest.pageModule;
+    }
+    throw new Error(
+      "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+    );
+  }
+}
+function createContainerEnvironment({
+  interner,
+  resolve,
+  renderers,
+  streaming
+}) {
+  async function getComponentByRoute(_manifest, routeData) {
+    const page = interner.get(routeData);
+    if (page) {
+      return page.page();
+    }
+    throw new Error("Couldn't find component for route " + routeData.pathname);
+  }
+  return {
+    name: "container",
+    runtimeMode: "development",
+    defaultStreaming: () => streaming,
+    async resolve(_manifest, specifier) {
+      return resolve(specifier);
+    },
+    headElements(manifest, routeData) {
+      const routeInfo = manifest.routes.find((route) => route.routeData === routeData);
+      const links = /* @__PURE__ */ new Set();
+      const scripts = /* @__PURE__ */ new Set();
+      const styles = createStylesheetElementSet(routeInfo?.styles ?? []);
+      for (const script of routeInfo?.scripts ?? []) {
+        if ("stage" in script) {
+          if (script.stage === "head-inline") {
+            scripts.add({
+              props: {},
+              children: script.children
+            });
+          }
+        } else {
+          scripts.add(createModuleScriptElement(script));
+        }
+      }
+      return { links, styles, scripts };
+    },
+    componentMetadata() {
+    },
+    getComponentByRoute,
+    getModuleForRoute,
+    async tryRewrite(manifest, payload, request) {
+      const { newUrl, pathname, routeData } = findRouteToRewrite({
+        payload,
+        request,
+        // PER-CALL scan of the live manifest routes: the container inserts
+        // routes at runtime (`insertRoute` pushes into `manifest.routes`),
+        // and an uncompiled scan sees them immediately. Reading the derived
+        // route table here would miss them.
+        routes: manifest.routes.map((r) => r.routeData),
+        trailingSlash: manifest.trailingSlash,
+        buildFormat: manifest.buildFormat,
+        base: manifest.base,
+        outDir: manifest.outDir
+      });
+      const componentInstance = await getComponentByRoute(manifest, routeData);
+      return { componentInstance, routeData, newUrl, pathname };
+    },
+    getRenderers() {
+      return renderers;
+    },
+    errorStrategy: "default",
+    injectCspMetaTagsOnErrorPages: false,
+    logRequest() {
+    }
+  };
+}
+export {
+  createContainerEnvironment
+};