astro 7.0.0-alpha.0 → 7.0.0-alpha.2

package/dist/core/app/dev/app.js

@@ -1,10 +1,6 @@
-import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "../../errors/errors-data.js";
-import { isAstroError } from "../../errors/index.js";
-import {
-  BaseApp
-} from "../base.js";
+import { DevErrorHandler } from "../../errors/dev-handler.js";
+import { BaseApp } from "../base.js";
 import { NonRunnablePipeline } from "./pipeline.js";
-import { getCustom404Route, getCustom500Route } from "../../routing/helpers.js";
 import { ensure404Route } from "../../routing/astro-designed-error-pages.js";
 import { matchRoute } from "../../routing/dev.js";
 import { req } from "../../messages/runtime.js";
@@ -53,60 +49,8 @@ class DevApp extends BaseApp {
       resolvedPathname: matchedRoute.resolvedPathname
     };
   }
-  async renderError(request, {
-    skipMiddleware = false,
-    error,
-    status,
-    response: _response,
-    ...resolvedRenderOptions
-  }) {
-    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
-      throw error;
-    }
-    const renderRoute = async (routeData) => {
-      try {
-        const preloadedComponent = await this.pipeline.getComponentByRoute(routeData);
-        const renderContext = await this.createRenderContext({
-          locals: resolvedRenderOptions.locals,
-          pipeline: this.pipeline,
-          pathname: this.getPathnameFromRequest(request),
-          skipMiddleware,
-          request,
-          routeData,
-          clientAddress: resolvedRenderOptions.clientAddress,
-          status,
-          shouldInjectCspMetaTags: false
-        });
-        renderContext.props.error = error;
-        const response = await renderContext.render(preloadedComponent);
-        if (error) {
-          this.logger.error("router", error.stack || error.message);
-        }
-        return response;
-      } catch (_err) {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status: 500,
-            skipMiddleware: true,
-            error: _err
-          });
-        }
-        throw _err;
-      }
-    };
-    if (status === 404) {
-      const custom404 = getCustom404Route(this.manifestData);
-      if (custom404) {
-        return renderRoute(custom404);
-      }
-    }
-    const custom500 = getCustom500Route(this.manifestData);
-    if (!custom500) {
-      throw error;
-    } else {
-      return renderRoute(custom500);
-    }
+  createErrorHandler() {
+    return new DevErrorHandler(this, { shouldInjectCspMetaTags: false });
   }
   logRequest({ pathname, method, statusCode, isRewrite, reqTime }) {
     if (pathname === "/favicon.ico") {

package/dist/core/app/entrypoints/node.d.ts

@@ -1 +1 @@
-export { NodeApp, loadApp, loadManifest, createRequest, writeResponse, getAbortControllerCleanup, } from '../node.js';
+export { NodeApp, loadApp, loadManifest, createRequest, createRequestFromNodeRequest, writeResponse, getAbortControllerCleanup, } from '../node.js';

package/dist/core/app/entrypoints/node.js

@@ -3,12 +3,14 @@ import {
   loadApp,
   loadManifest,
   createRequest,
+  createRequestFromNodeRequest,
   writeResponse,
   getAbortControllerCleanup
 } from "../node.js";
 export {
   NodeApp,
   createRequest,
+  createRequestFromNodeRequest,
   getAbortControllerCleanup,
   loadApp,
   loadManifest,

package/dist/core/app/entrypoints/virtual/dev.js

@@ -1,3 +1,4 @@
+import fetchable from "virtual:astro:fetchable";
 import { manifest } from "virtual:astro:manifest";
 import { DevApp } from "../../dev/app.js";
 import { createConsoleLogger } from "../../../logger/impls/console.js";
@@ -5,6 +6,7 @@ let currentDevApp = null;
 const createApp = ({ streaming } = {}) => {
   const logger = createConsoleLogger(manifest.logLevel);
   currentDevApp = new DevApp(manifest, streaming, logger);
+  currentDevApp.setFetchHandler(fetchable);
   if (import.meta.hot) {
     import.meta.hot.on("astro:routes-updated", async () => {
       if (!currentDevApp) return;

package/dist/core/app/entrypoints/virtual/prod.js

@@ -1,7 +1,10 @@
+import fetchable from "virtual:astro:fetchable";
 import { manifest } from "virtual:astro:manifest";
 import { App } from "../../app.js";
 const createApp = ({ streaming } = {}) => {
-  return new App(manifest, streaming);
+  const app = new App(manifest, streaming);
+  app.setFetchHandler(fetchable);
+  return app;
 };
 export {
   createApp

package/dist/core/app/node.d.ts

@@ -25,6 +25,22 @@ interface NodeRequest extends IncomingMessage {
  * })
  * ```
  */
+/**
+ * Internal version of `createRequest` that skips X-Forwarded-* header
+ * validation. Forwarded headers are resolved later inside `FetchState`,
+ * so doing it here too would duplicate work on every request.
+ *
+ * Use this for all internal call sites that go through `app.render()`
+ * (which creates a `FetchState`). The public `createRequest` keeps the
+ * forwarded header logic for external adapters that may not use
+ * `FetchState`.
+ */
+export declare function createRequestFromNodeRequest(req: NodeRequest, { skipBody, allowedDomains, bodySizeLimit, port: serverPort, }?: {
+    skipBody?: boolean;
+    allowedDomains?: Partial<RemotePattern>[];
+    bodySizeLimit?: number;
+    port?: number;
+}): Request;
 export declare function createRequest(req: NodeRequest, { skipBody, allowedDomains, bodySizeLimit, port: serverPort, }?: {
     skipBody?: boolean;
     allowedDomains?: Partial<RemotePattern>[];

package/dist/core/app/node.js

@@ -9,6 +9,48 @@ import {
   validateForwardedHeaders,
   validateHost
 } from "./validate-headers.js";
+function createRequestFromNodeRequest(req, {
+  skipBody = false,
+  allowedDomains = [],
+  bodySizeLimit,
+  port: serverPort
+} = {}) {
+  const controller = new AbortController();
+  const isEncrypted = "encrypted" in req.socket && req.socket.encrypted;
+  const protocol = isEncrypted ? "https" : "http";
+  const hostname = typeof req.headers.host === "string" ? req.headers.host : typeof req.headers[":authority"] === "string" ? req.headers[":authority"] : serverPort ? `localhost:${serverPort}` : "localhost";
+  let url;
+  try {
+    url = new URL(`${protocol}://${hostname}${req.url}`);
+  } catch {
+    url = new URL(`${protocol}://${hostname}`);
+  }
+  const options = {
+    method: req.method || "GET",
+    headers: makeRequestHeaders(req),
+    signal: controller.signal
+  };
+  const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
+  if (bodyAllowed) {
+    Object.assign(options, makeRequestBody(req, bodySizeLimit));
+  }
+  const request = new Request(url, options);
+  wireAbortController(req, controller);
+  const untrustedHostname = req.headers.host ?? req.headers[":authority"];
+  const validatedHostname = validateHost(
+    typeof untrustedHostname === "string" ? untrustedHostname : void 0,
+    protocol,
+    allowedDomains
+  );
+  const forwardedHost = getFirstForwardedValue(req.headers["x-forwarded-host"]);
+  const hostValidated = validatedHostname !== void 0 || forwardedHost !== void 0 && allowedDomains.length > 0;
+  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
+  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
+  if (clientIp) {
+    Reflect.set(request, clientAddressSymbol, clientIp);
+  }
+  return request;
+}
 function createRequest(req, {
   skipBody = false,
   allowedDomains = [],
@@ -51,6 +93,16 @@ function createRequest(req, {
     Object.assign(options, makeRequestBody(req, bodySizeLimit));
   }
   const request = new Request(url, options);
+  wireAbortController(req, controller);
+  const hostValidated = validated.host !== void 0 || validatedHostname !== void 0;
+  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
+  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
+  if (clientIp) {
+    Reflect.set(request, clientAddressSymbol, clientIp);
+  }
+  return request;
+}
+function wireAbortController(req, controller) {
   const socket = getRequestSocket(req);
   if (socket && typeof socket.on === "function") {
     const existingCleanup = getAbortControllerCleanup(req);
@@ -85,13 +137,6 @@ function createRequest(req, {
       onSocketClose();
     }
   }
-  const hostValidated = validated.host !== void 0 || validatedHostname !== void 0;
-  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
-  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
-  if (clientIp) {
-    Reflect.set(request, clientAddressSymbol, clientIp);
-  }
-  return request;
 }
 async function writeResponse(source, destination) {
   const { status, headers, body, statusText } = source;
@@ -147,18 +192,15 @@ class NodeApp extends App {
   }
   match(req, allowPrerenderedRoutes = false) {
     if (!(req instanceof Request)) {
-      req = createRequest(req, {
-        skipBody: true,
-        allowedDomains: this.manifest.allowedDomains
+      req = createRequestFromNodeRequest(req, {
+        skipBody: true
       });
     }
     return super.match(req, allowPrerenderedRoutes);
   }
   render(request, options) {
     if (!(request instanceof Request)) {
-      request = createRequest(request, {
-        allowedDomains: this.manifest.allowedDomains
-      });
+      request = createRequestFromNodeRequest(request);
     }
     return super.render(request, options);
   }
@@ -219,6 +261,9 @@ function makeRequestBody(req, bodySizeLimit) {
     if (typeof req.body === "string" && req.body.length > 0) {
       return { body: Buffer.from(req.body) };
     }
+    if (req.body instanceof ArrayBuffer || ArrayBuffer.isView(req.body)) {
+      return { body: req.body };
+    }
     if (typeof req.body === "object" && req.body !== null && Object.keys(req.body).length > 0) {
       return { body: Buffer.from(JSON.stringify(req.body)) };
     }
@@ -280,6 +325,7 @@ async function loadApp(rootFolder) {
 export {
   NodeApp,
   createRequest,
+  createRequestFromNodeRequest,
   getAbortControllerCleanup,
   loadApp,
   loadManifest,

package/dist/core/app/prepare-response.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Strips internal-only headers from the response before sending it to the
+ * user agent, and optionally appends cookies written via `Astro.cookie.set()`
+ * to the `Set-Cookie` header.
+ *
+ * This is a pure function with no dependencies on the app; it is shared by
+ * `AstroHandler` and the various error handlers.
+ */
+export declare function prepareResponse(response: Response, { addCookieHeader }: {
+    addCookieHeader: boolean;
+}): void;

package/dist/core/app/prepare-response.js

@@ -0,0 +1,18 @@
+import { INTERNAL_RESPONSE_HEADERS, responseSentSymbol } from "../constants.js";
+import { getSetCookiesFromResponse } from "../cookies/index.js";
+function prepareResponse(response, { addCookieHeader }) {
+  for (const headerName of INTERNAL_RESPONSE_HEADERS) {
+    if (response.headers.has(headerName)) {
+      response.headers.delete(headerName);
+    }
+  }
+  if (addCookieHeader) {
+    for (const setCookieHeaderValue of getSetCookiesFromResponse(response)) {
+      response.headers.append("set-cookie", setCookieHeaderValue);
+    }
+  }
+  Reflect.set(response, responseSentSymbol, true);
+}
+export {
+  prepareResponse
+};

package/dist/core/app/render-options.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedRenderOptions } from './base.js';
+/**
+ * Reads `ResolvedRenderOptions` that were attached to a request via
+ * `renderOptionsSymbol`. Returns `undefined` if no options are attached.
+ */
+export declare function getRenderOptions(request: Request): ResolvedRenderOptions | undefined;
+/**
+ * Attaches `ResolvedRenderOptions` to a request via `renderOptionsSymbol` so
+ * that downstream handlers can read them.
+ */
+export declare function setRenderOptions(request: Request, options: ResolvedRenderOptions): void;

package/dist/core/app/render-options.js

@@ -0,0 +1,11 @@
+const renderOptionsSymbol = /* @__PURE__ */ Symbol.for("astro.renderOptions");
+function getRenderOptions(request) {
+  return Reflect.get(request, renderOptionsSymbol);
+}
+function setRenderOptions(request, options) {
+  Reflect.set(request, renderOptionsSymbol, options);
+}
+export {
+  getRenderOptions,
+  setRenderOptions
+};

package/dist/core/base-pipeline.d.ts

@@ -14,13 +14,32 @@ import type { CompiledCacheRoute } from './cache/runtime/route-matching.js';
 import type { SessionDriverFactory } from './session/types.js';
 import { NodePool } from '../runtime/server/render/queue/pool.js';
 import { HTMLStringCache } from '../runtime/server/html-string-cache.js';
+/**
+ * Bit flags for pipeline features that handler classes register as
+ * "used" when a custom `src/app.ts` fetch handler is in play. After the
+ * first request (dev) or at runtime (prod SSR), we compare against the
+ * manifest to warn about features the user configured but forgot to
+ * include in their custom pipeline.
+ */
+export declare const PipelineFeatures: {
+    readonly redirects: number;
+    readonly sessions: number;
+    readonly actions: number;
+    readonly middleware: number;
+    readonly i18n: number;
+    readonly cache: number;
+};
+/** All feature bits ORed together. Keep next to `PipelineFeatures` so
+ *  new flags are hard to forget. */
+export declare const ALL_PIPELINE_FEATURES: number;
 /**
  * The `Pipeline` represents the static parts of rendering that do not change between requests.
  * These are mostly known when the server first starts up and do not change.
  *
- * Thus, a `Pipeline` is created once at process start and then used by every `RenderContext`.
+ * Thus, a `Pipeline` is created once at process start and then used by every `FetchState`.
  */
 export declare abstract class Pipeline {
+    #private;
     readonly internalMiddleware: MiddlewareHandler[];
     resolvedMiddleware: MiddlewareHandler | undefined;
     resolvedLogger: boolean;
@@ -30,6 +49,12 @@ export declare abstract class Pipeline {
     compiledCacheRoutes: CompiledCacheRoute[] | undefined;
     nodePool: NodePool | undefined;
     htmlStringCache: HTMLStringCache | undefined;
+    /**
+     * Bit mask of pipeline features activated by handler classes.
+     * Each handler sets its bit via `|=`. Only meaningful when a
+     * custom `src/app.ts` fetch handler is in use.
+     */
+    usedFeatures: number;
     logger: AstroLogger;
     readonly manifest: SSRManifest;
     /**
@@ -63,6 +88,10 @@ export declare abstract class Pipeline {
     readonly cacheProvider: SSRManifest['cacheProvider'];
     readonly cacheConfig: SSRManifest['cacheConfig'];
     readonly serverIslands: SSRManifest['serverIslandMappings'];
+    /** Route data derived from the manifest, used for route matching. */
+    manifestData: {
+        routes: RouteData[];
+    };
     constructor(logger: AstroLogger, manifest: SSRManifest, 
     /**
      * "development" or "production" only
@@ -85,6 +114,24 @@ export declare abstract class Pipeline {
     }>) | undefined, cacheProvider?: (() => Promise<{
         default: CacheProviderFactory | null;
     }>) | undefined, cacheConfig?: import("./cache/types.js").SSRManifestCache | undefined, serverIslands?: (() => Promise<ServerIslandMappings> | ServerIslandMappings) | undefined);
+    /**
+     * Low-level route matching against the manifest routes. Returns the
+     * matched `RouteData` or `undefined`. Does not filter prerendered
+     * routes or check public assets — use `BaseApp.match()` for that.
+     */
+    matchRoute(pathname: string): RouteData | undefined;
+    /**
+     * Returns all routes matching the given pathname, in priority order.
+     * Used when the first match cannot serve the request (e.g. a
+     * prerendered dynamic route that doesn't cover this specific path)
+     * and the caller needs to try subsequent matches.
+     */
+    matchAllRoutes(pathname: string): RouteData[];
+    /**
+     * Rebuilds the internal router after routes have been added or
+     * removed (e.g. by the dev server on HMR).
+     */
+    rebuildRouter(): void;
     abstract headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
     abstract componentMetadata(routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
     /**

package/dist/core/base-pipeline.js

@@ -1,5 +1,4 @@
 import { NOOP_ACTIONS_MOD } from "../actions/noop-actions.js";
-import { createI18nMiddleware } from "../i18n/middleware.js";
 import { createOriginCheckMiddleware } from "./app/middlewares.js";
 import { ActionNotFoundError } from "./errors/errors-data.js";
 import { AstroError } from "./errors/index.js";
@@ -8,10 +7,21 @@ import { sequence } from "./middleware/sequence.js";
 import { RedirectSinglePageBuiltModule } from "./redirects/index.js";
 import { RouteCache } from "./render/route-cache.js";
 import { createDefaultRoutes } from "./routing/default.js";
+import { ensure404Route } from "./routing/astro-designed-error-pages.js";
+import { Router } from "./routing/router.js";
 import { NodePool } from "../runtime/server/render/queue/pool.js";
 import { HTMLStringCache } from "../runtime/server/html-string-cache.js";
 import { FORBIDDEN_PATH_KEYS } from "@astrojs/internal-helpers/object";
 import { loadLogger } from "./logger/load.js";
+const PipelineFeatures = {
+  redirects: 1 << 0,
+  sessions: 1 << 1,
+  actions: 1 << 2,
+  middleware: 1 << 3,
+  i18n: 1 << 4,
+  cache: 1 << 5
+};
+const ALL_PIPELINE_FEATURES = PipelineFeatures.redirects | PipelineFeatures.sessions | PipelineFeatures.actions | PipelineFeatures.middleware | PipelineFeatures.i18n | PipelineFeatures.cache;
 class Pipeline {
   internalMiddleware;
   resolvedMiddleware = void 0;
@@ -22,6 +32,12 @@ class Pipeline {
   compiledCacheRoutes = void 0;
   nodePool;
   htmlStringCache;
+  /**
+   * Bit mask of pipeline features activated by handler classes.
+   * Each handler sets its bit via `|=`. Only meaningful when a
+   * custom `src/app.ts` fetch handler is in use.
+   */
+  usedFeatures = 0;
   logger;
   manifest;
   /**
@@ -55,6 +71,10 @@ class Pipeline {
   cacheProvider;
   cacheConfig;
   serverIslands;
+  /** Route data derived from the manifest, used for route matching. */
+  manifestData;
+  /** Pattern-matching router built from manifestData. */
+  #router;
   constructor(logger, manifest, runtimeMode, renderers, resolve, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : void 0, defaultRoutes = createDefaultRoutes(manifest), actions = manifest.actions, sessionDriver = manifest.sessionDriver, cacheProvider = manifest.cacheProvider, cacheConfig = manifest.cacheConfig, serverIslands = manifest.serverIslandMappings) {
     this.logger = logger;
     this.manifest = manifest;
@@ -76,12 +96,14 @@ class Pipeline {
     this.cacheProvider = cacheProvider;
     this.cacheConfig = cacheConfig;
     this.serverIslands = serverIslands;
+    this.manifestData = { routes: (manifest.routes ?? []).map((route) => route.routeData) };
+    ensure404Route(this.manifestData);
+    this.#router = new Router(this.manifestData.routes, {
+      base: manifest.base,
+      trailingSlash: manifest.trailingSlash,
+      buildFormat: manifest.buildFormat
+    });
     this.internalMiddleware = [];
-    if (i18n?.strategy !== "manual") {
-      this.internalMiddleware.push(
-        createI18nMiddleware(i18n, manifest.base, manifest.trailingSlash, manifest.buildFormat)
-      );
-    }
     if (manifest.experimentalQueuedRendering.enabled) {
       this.nodePool = this.createNodePool(
         manifest.experimentalQueuedRendering.poolSize ?? 1e3,
@@ -92,6 +114,36 @@ class Pipeline {
       }
     }
   }
+  /**
+   * Low-level route matching against the manifest routes. Returns the
+   * matched `RouteData` or `undefined`. Does not filter prerendered
+   * routes or check public assets — use `BaseApp.match()` for that.
+   */
+  matchRoute(pathname) {
+    const match = this.#router.match(pathname, { allowWithoutBase: true });
+    if (match.type !== "match") return void 0;
+    return match.route;
+  }
+  /**
+   * Returns all routes matching the given pathname, in priority order.
+   * Used when the first match cannot serve the request (e.g. a
+   * prerendered dynamic route that doesn't cover this specific path)
+   * and the caller needs to try subsequent matches.
+   */
+  matchAllRoutes(pathname) {
+    return this.#router.matchAll(pathname, { allowWithoutBase: true });
+  }
+  /**
+   * Rebuilds the internal router after routes have been added or
+   * removed (e.g. by the dev server on HMR).
+   */
+  rebuildRouter() {
+    this.#router = new Router(this.manifestData.routes, {
+      base: this.manifest.base,
+      trailingSlash: this.manifest.trailingSlash,
+      buildFormat: this.manifest.buildFormat
+    });
+  }
   /**
    * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
    * it returns a no-op function
@@ -140,7 +192,8 @@ class Pipeline {
     if (this.resolvedActions) {
       return this.resolvedActions;
     } else if (this.actions) {
-      return this.actions();
+      this.resolvedActions = await this.actions();
+      return this.resolvedActions;
     }
     return NOOP_ACTIONS_MOD;
   }
@@ -243,5 +296,7 @@ class Pipeline {
   }
 }
 export {
-  Pipeline
+  ALL_PIPELINE_FEATURES,
+  Pipeline,
+  PipelineFeatures
 };

package/dist/core/build/app.d.ts

@@ -1,20 +1,19 @@
-import { BaseApp, type RenderErrorOptions } from '../app/entrypoints/index.js';
+import { BaseApp } from '../app/entrypoints/index.js';
 import type { SSRManifest } from '../app/types.js';
 import type { BuildInternals } from './internal.js';
 import { BuildPipeline } from './pipeline.js';
 import type { StaticBuildOptions } from './types.js';
-import type { CreateRenderContext, RenderContext } from '../render-context.js';
 import type { LogRequestPayload } from '../app/base.js';
+import type { ErrorHandler } from '../errors/handler.js';
 import type { PoolStatsReport } from '../../runtime/server/render/queue/pool.js';
 export declare class BuildApp extends BaseApp<BuildPipeline> {
     createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
-    createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
     isDev(): boolean;
     setInternals(internals: BuildInternals): void;
     setOptions(options: StaticBuildOptions): void;
     getOptions(): StaticBuildOptions;
     getSettings(): import("../../types/astro.js").AstroSettings;
-    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+    protected createErrorHandler(): ErrorHandler;
     getQueueStats(): PoolStatsReport | undefined;
     logRequest(_options: LogRequestPayload): void;
 }

package/dist/core/build/app.js

@@ -1,16 +1,12 @@
 import { BaseApp } from "../app/entrypoints/index.js";
 import { BuildPipeline } from "./pipeline.js";
+import { BuildErrorHandler } from "../errors/build-handler.js";
 class BuildApp extends BaseApp {
   createPipeline(_streaming, manifest, ..._args) {
     return BuildPipeline.create({
       manifest
     });
   }
-  async createRenderContext(payload) {
-    return await super.createRenderContext({
-      ...payload
-    });
-  }
   isDev() {
     return true;
   }
@@ -28,18 +24,8 @@ class BuildApp extends BaseApp {
   getSettings() {
     return this.pipeline.getSettings();
   }
-  async renderError(request, options) {
-    if (options.status === 500) {
-      if (options.response) {
-        return options.response;
-      }
-      throw options.error;
-    } else {
-      return super.renderError(request, {
-        ...options,
-        prerenderedErrorPageFetch: void 0
-      });
-    }
+  createErrorHandler() {
+    return new BuildErrorHandler(this);
   }
   getQueueStats() {
     if (this.pipeline.nodePool) {

package/dist/core/build/generate.js

@@ -187,13 +187,20 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
     const cpuCount = os.cpus().length;
     const assetsCreationPipeline = await prepareAssetsGenerationEnv(options, totalCount);
     const queue = new PQueue({ concurrency: Math.max(cpuCount, 1) });
+    const errors = [];
     const assetsTimer = performance.now();
     for (const [originalPath, transforms] of staticImageList) {
       queue.add(() => generateImagesForPath(originalPath, transforms, assetsCreationPipeline)).catch((e) => {
-        throw e;
+        logger.warn("build", `Unable to generate optimized image for ${originalPath}: ${e}`);
+        errors.push(new Error(`Error generating image for ${originalPath}: ${e}`, { cause: e }));
       });
     }
     await queue.onIdle();
+    if (errors.length === 1) {
+      throw errors[0];
+    } else if (errors.length > 1) {
+      throw new AggregateError(errors, `${errors.length} errors occurred during asset generation`);
+    }
     const assetsTimeEnd = performance.now();
     logger.info(null, colors.green(`\u2713 Completed in ${getTimeStat(assetsTimer, assetsTimeEnd)}.
 `));

package/dist/core/build/index.d.ts

@@ -9,16 +9,6 @@ interface BuildOptions {
      * @default false
      */
     devOutput?: boolean;
-    /**
-     * Teardown the compiler WASM instance after build. This can improve performance when
-     * building once, but may cause a performance hit if building multiple times in a row.
-     *
-     * When building multiple projects in the same execution (e.g. during tests), disabling
-     * this option can greatly improve performance at the cost of some extra memory usage.
-     *
-     * @default true
-     */
-    teardownCompiler?: boolean;
 }
 /**
  * Builds your site for deployment. By default, this will generate static files and place them in a dist/ directory.
@@ -50,7 +40,6 @@ export declare class AstroBuilder {
     private origin;
     private routesList;
     private timer;
-    private teardownCompiler;
     private sync;
     constructor(settings: AstroSettings, options: AstroBuilderOptions);
     /** Setup Vite and run any async setup logic that couldn't run inside of the constructor. */

package/dist/core/build/index.js

@@ -55,14 +55,12 @@ class AstroBuilder {
   origin;
   routesList;
   timer;
-  teardownCompiler;
   sync;
   constructor(settings, options) {
     this.mode = options.mode;
     this.runtimeMode = options.runtimeMode;
     this.settings = settings;
     this.logger = options.logger;
-    this.teardownCompiler = options.teardownCompiler ?? true;
     this.sync = options.sync ?? true;
     this.origin = settings.config.site ? new URL(settings.config.site).origin : `http://localhost:${settings.config.server.port}`;
     this.routesList = options.routesList ?? { routes: [] };
@@ -151,7 +149,6 @@ class AstroBuilder {
       runtimeMode: this.runtimeMode,
       origin: this.origin,
       pageNames,
-      teardownCompiler: this.teardownCompiler,
       viteConfig,
       key: keyPromise
     };