astro 7.2.2 → 7.2.4

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/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/utils/vendor/image-size/types/heif.js

@@ -46,20 +46,25 @@ const HEIF = {
     const type = detectType(input, 8, metaBox.offset);
     const images = [];
     let currentOffset = ipcoBox.offset + 8;
-    while (currentOffset < ipcoBox.offset + ipcoBox.size) {
+    const ipcoEnd = ipcoBox.offset + ipcoBox.size;
+    while (currentOffset < ipcoEnd) {
       const ispeBox = findBox(input, "ispe", currentOffset);
       if (!ispeBox) break;
+      if (ispeBox.size < 8) break;
+      if (ispeBox.offset + ispeBox.size > ipcoEnd) break;
       const rawWidth = readUInt32BE(input, ispeBox.offset + 12);
       const rawHeight = readUInt32BE(input, ispeBox.offset + 16);
       const clapBox = findBox(input, "clap", currentOffset);
       let width = rawWidth;
       let height = rawHeight;
-      if (clapBox && clapBox.offset < ipcoBox.offset + ipcoBox.size) {
+      if (clapBox && clapBox.offset < ipcoEnd && clapBox.size >= 8) {
         const cropRight = readUInt32BE(input, clapBox.offset + 12);
         width = rawWidth - cropRight;
       }
       images.push({ height, width });
-      currentOffset = ispeBox.offset + ispeBox.size;
+      const nextOffset = ispeBox.offset + ispeBox.size;
+      if (nextOffset <= currentOffset) break;
+      currentOffset = nextOffset;
     }
     if (images.length === 0) {
       throw new TypeError("Invalid HEIF, no sizes found");

package/dist/assets/utils/vendor/image-size/types/icns.js

@@ -1,6 +1,7 @@
 import { readUInt32BE, toUTF8String } from "./utils.js";
 const SIZE_HEADER = 4 + 4;
 const FILE_LENGTH_OFFSET = 4;
+const MIN_ENTRY_LENGTH = 8;
 const ENTRY_LENGTH_OFFSET = 4;
 const ICON_TYPE_SIZE = {
   ICON: 32,
@@ -63,10 +64,17 @@ const ICNS = {
     let imageOffset = SIZE_HEADER;
     const images = [];
     while (imageOffset < fileLength && imageOffset < inputLength) {
+      if (inputLength - imageOffset < MIN_ENTRY_LENGTH) break;
       const imageHeader = readImageHeader(input, imageOffset);
+      const entryLength = imageHeader[1];
+      if (entryLength < MIN_ENTRY_LENGTH) break;
       const imageSize = getImageSize(imageHeader[0]);
-      images.push(imageSize);
-      imageOffset += imageHeader[1];
+      if (imageSize.width && imageSize.height) {
+        images.push(imageSize);
+      }
+      const nextOffset = imageOffset + entryLength;
+      if (nextOffset <= imageOffset) break;
+      imageOffset = nextOffset;
     }
     if (images.length === 0) {
       throw new TypeError("Invalid ICNS, no sizes found");

package/dist/assets/utils/vendor/image-size/types/jp2.js

@@ -10,8 +10,8 @@ const JP2 = {
   },
   calculate(input) {
     const jp2hBox = findBox(input, "jp2h", 0);
-    const ihdrBox = jp2hBox && findBox(input, "ihdr", jp2hBox.offset + 8);
-    if (ihdrBox) {
+    const ihdrBox = jp2hBox && jp2hBox.size >= 8 && findBox(input, "ihdr", jp2hBox.offset + 8);
+    if (ihdrBox && ihdrBox.size >= 8) {
       return {
         height: readUInt32BE(input, ihdrBox.offset + 8),
         width: readUInt32BE(input, ihdrBox.offset + 12)

package/dist/assets/utils/vendor/image-size/types/jxl.js

@@ -2,7 +2,7 @@ import { JXLStream } from "./jxl-stream.js";
 import { findBox, toUTF8String } from "./utils.js";
 function extractCodestream(input) {
   const jxlcBox = findBox(input, "jxlc", 0);
-  if (jxlcBox) {
+  if (jxlcBox && jxlcBox.size >= 8) {
     return input.slice(jxlcBox.offset + 8, jxlcBox.offset + jxlcBox.size);
   }
   const partialStreams = extractPartialStreams(input);
@@ -17,10 +17,13 @@ function extractPartialStreams(input) {
   while (offset < input.length) {
     const jxlpBox = findBox(input, "jxlp", offset);
     if (!jxlpBox) break;
+    if (jxlpBox.size < 12) break;
     partialStreams.push(
       input.slice(jxlpBox.offset + 12, jxlpBox.offset + jxlpBox.size)
     );
-    offset = jxlpBox.offset + jxlpBox.size;
+    const nextOffset = jxlpBox.offset + jxlpBox.size;
+    if (nextOffset <= offset) break;
+    offset = nextOffset;
   }
   return partialStreams;
 }

package/dist/assets/utils/vendor/image-size/types/utils.d.ts

@@ -9,7 +9,7 @@ export declare const readUInt32BE: (input: Uint8Array, offset?: number) => numbe
 export declare const readUInt32LE: (input: Uint8Array, offset?: number) => number;
 export declare const readUInt64: (input: Uint8Array, offset: number, isBigEndian: boolean) => bigint;
 export declare function readUInt(input: Uint8Array, bits: 16 | 32, offset?: number, isBigEndian?: boolean): number;
-export declare function findBox(input: Uint8Array, boxName: string, currentOffset: number): {
+export declare function findBox(input: Uint8Array, boxName: string, startOffset: number): {
     name: string;
     offset: number;
     size: number;

package/dist/assets/utils/vendor/image-size/types/utils.js

@@ -24,22 +24,36 @@ function readUInt(input, bits, offset = 0, isBigEndian = false) {
   const methodName = `readUInt${bits}${endian}`;
   return methods[methodName](input, offset);
 }
+const MIN_BOX_HEADER = 8;
 function readBox(input, offset) {
-  if (input.length - offset < 4) return;
+  if (input.length - offset < MIN_BOX_HEADER) return;
   const boxSize = readUInt32BE(input, offset);
+  if (boxSize === 0) {
+    return {
+      name: toUTF8String(input, offset + 4, offset + 8),
+      offset,
+      size: input.length - offset
+    };
+  }
+  if (boxSize === 1) return;
+  if (boxSize < MIN_BOX_HEADER) return;
   if (input.length - offset < boxSize) return;
   return {
-    name: toUTF8String(input, 4 + offset, 8 + offset),
+    name: toUTF8String(input, offset + 4, offset + 8),
     offset,
     size: boxSize
   };
 }
-function findBox(input, boxName, currentOffset) {
-  while (currentOffset < input.length) {
-    const box = readBox(input, currentOffset);
+function findBox(input, boxName, startOffset) {
+  let offset = startOffset;
+  while (offset < input.length) {
+    const box = readBox(input, offset);
     if (!box) break;
     if (box.name === boxName) return box;
-    currentOffset += box.size > 0 ? box.size : 8;
+    if (box.size < MIN_BOX_HEADER) break;
+    const nextOffset = offset + box.size;
+    if (nextOffset <= offset) break;
+    offset = nextOffset;
   }
 }
 export {

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

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
+};