astro 7.2.2 → 7.2.3

package/dist/core/app/base.js

@@ -5,23 +5,30 @@ import {
 } from "@astrojs/internal-helpers/path";
 import { matchPattern } from "@astrojs/internal-helpers/remote";
 import { computePathnameFromDomain } from "../i18n/domain.js";
-import { isLocalizedErrorRoute } from "../../i18n/error-routes.js";
-import { PipelineFeatures } from "../base-pipeline.js";
 import { ASTRO_ERROR_HEADER, clientAddressSymbol } from "../constants.js";
 import { getSetCookiesFromResponse } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { AstroIntegrationLogger } from "../logger/core.js";
 import { DefaultFetchHandler } from "../fetch/default-handler.js";
-import { appSymbol } from "../constants.js";
-import { DefaultErrorHandler } from "../errors/default-handler.js";
-import { isRoute404, isRoute500 } from "../routing/internal/route-errors.js";
+import { getUsedFeatures, FetchFeatures } from "../fetch/features.js";
+import { FetchState } from "../fetch/fetch-state.js";
+import { renderErrorPage } from "../errors/handler.js";
+import { getLogger, getResolvedLogger } from "../logger/manifest-logger.js";
+import { handleRequest } from "../routing/handler.js";
+import { getDefaultStatusCode } from "../routing/helpers.js";
+import { matchRequest } from "../routing/match-request.js";
+import { getRouteTable, matchRoute, updateRouteTable } from "../routing/route-table.js";
 import { setRenderOptions } from "./render-options.js";
 class BaseApp {
   manifest;
-  manifestData;
-  pipeline;
   #adapterLogger;
   baseWithoutTrailingSlash;
+  /**
+   * The streaming flag passed to the constructor, surfaced through the
+   * protected `resolveStreaming()` hook and fed into the internal
+   * `FetchState` facade hooks on the fast path.
+   */
+  #streaming;
   /**
    * The handler that turns incoming `Request` objects into `Response`s.
    * Defaults to a `DefaultFetchHandler` pinned to this app and can be
@@ -42,7 +49,18 @@ class BaseApp {
    */
   #featureCheckDone = false;
   get logger() {
-    return this.pipeline.logger;
+    return getLogger(this.manifest);
+  }
+  /**
+   * Route data derived from the manifest, used for route matching. Reads and
+   * writes go through the single per-manifest route table, so HMR updates are
+   * visible to every consumer at once.
+   */
+  get manifestData() {
+    return getRouteTable(this.manifest);
+  }
+  set manifestData(routesList) {
+    updateRouteTable(this.manifest, routesList.routes);
   }
   get adapterLogger() {
     const currentOptions = this.logger.options;
@@ -51,14 +69,33 @@ class BaseApp {
     }
     return this.#adapterLogger;
   }
-  constructor(manifest, streaming = true, ...args) {
+  constructor(manifest, streaming = true) {
     this.manifest = manifest;
     this.baseWithoutTrailingSlash = removeTrailingForwardSlash(manifest.base);
-    this.pipeline = this.createPipeline(streaming, manifest, ...args);
-    this.manifestData = this.pipeline.manifestData;
+    this.#streaming = streaming;
+    getRouteTable(manifest);
+    getLogger(manifest);
     this.#fetchHandler = new DefaultFetchHandler(this);
     this.#errorHandler = this.createErrorHandler();
   }
+  /**
+   * Resolves the user-configured logger destination from the manifest and
+   * returns the logger. Lazy and only resolves once; safe to call before
+   * the first render (adapters use this to log startup messages through
+   * the configured destination).
+   */
+  getLogger() {
+    return getResolvedLogger(this.manifest);
+  }
+  /**
+   * The streaming flag fed into the internal `FetchState` facade hooks on
+   * the fast path. Returns the constructor flag by
+   * default; `BuildApp` overrides this to return `undefined` so streaming
+   * falls through to the environment default (`manifest.serverLike`).
+   */
+  resolveStreaming() {
+    return this.#streaming;
+  }
   /**
    * Override the fetch handler used to dispatch requests. Entrypoints
    * call this with the default export of `virtual:astro:fetchable` to
@@ -69,11 +106,15 @@ class BaseApp {
     this.#hasCustomFetchHandler = !(handler instanceof DefaultFetchHandler);
   }
   /**
-   * Returns the error handler strategy used by this app. Override to
-   * provide environment-specific behavior (dev overlay, build-time throws, etc.).
+   * Returns the error handler used by this app. The default is a thin
+   * bridge over the functional error API — strategy selection (production
+   * default / dev / build) is environment-driven inside `renderErrorPage`.
+   * External subclasses can override this to customize error rendering.
    */
   createErrorHandler() {
-    return new DefaultErrorHandler(this);
+    return {
+      renderError: (request, options) => renderErrorPage(this.manifest, request, options)
+    };
   }
   /**
    * Resets the cached adapter logger so it picks up a new logger instance.
@@ -102,9 +143,7 @@ class BaseApp {
     }
   }
   set setManifestData(newManifestData) {
-    this.manifestData = newManifestData;
-    this.pipeline.manifestData = newManifestData;
-    this.pipeline.rebuildRouter();
+    updateRouteTable(this.manifest, newManifestData.routes);
   }
   removeBase(pathname) {
     pathname = collapseDuplicateLeadingSlashes(pathname);
@@ -147,25 +186,7 @@ class BaseApp {
    * @param allowPrerenderedRoutes
    */
   match(request, allowPrerenderedRoutes = false) {
-    const url = new URL(request.url);
-    if (this.manifest.assets.has(url.pathname)) return void 0;
-    let pathname = this.computePathnameFromDomain(request);
-    if (!pathname) {
-      pathname = prependForwardSlash(this.removeBase(url.pathname));
-    }
-    const routeData = this.pipeline.matchRoute(this.safeDecodeURI(pathname));
-    if (!routeData) return void 0;
-    if (allowPrerenderedRoutes) {
-      return routeData;
-    }
-    if (routeData.prerender) {
-      if (routeData.params.length > 0) {
-        const allMatches = this.pipeline.matchAllRoutes(this.safeDecodeURI(pathname));
-        return allMatches.find((r) => !r.prerender);
-      }
-      return void 0;
-    }
-    return routeData;
+    return matchRequest(this.manifest, request, allowPrerenderedRoutes);
   }
   /**
    * A matching route function to use in the development server.
@@ -195,7 +216,7 @@ class BaseApp {
     routeData,
     waitUntil
   } = {}) {
-    await this.pipeline.getLogger();
+    await getResolvedLogger(this.manifest);
     if (routeData) {
       this.logger.debug(
         "router",
@@ -226,7 +247,7 @@ class BaseApp {
     if (!routeData) {
       const domainPathname = this.computePathnameFromDomain(request);
       if (domainPathname) {
-        routeData = this.pipeline.matchRoute(this.safeDecodeURI(domainPathname));
+        routeData = matchRoute(this.manifest, this.safeDecodeURI(domainPathname));
       }
     }
     const resolvedOptions = {
@@ -239,11 +260,15 @@ class BaseApp {
     };
     let response;
     if (this.#fetchHandler instanceof DefaultFetchHandler) {
-      Reflect.set(request, appSymbol, this);
-      response = await this.#fetchHandler.renderWithOptions(request, resolvedOptions);
+      response = await handleRequest(
+        new FetchState(this.manifest, request, resolvedOptions, {
+          streaming: this.resolveStreaming(),
+          renderError: (req, opts) => this.renderError(req, opts),
+          logRequest: (payload) => this.logThisRequest(payload)
+        })
+      );
     } else {
       setRenderOptions(request, resolvedOptions);
-      Reflect.set(request, appSymbol, this);
       response = await this.#fetchHandler.fetch(request);
     }
     this.#warnMissingFeatures();
@@ -299,52 +324,37 @@ class BaseApp {
     this.#featureCheckDone = true;
     const manifest = this.manifest;
     const missing = [];
-    const used = this.pipeline.usedFeatures;
-    if (manifest.routes.some((r) => r.routeData.type === "redirect") && !(used & PipelineFeatures.redirects)) {
+    const used = getUsedFeatures(this.manifest);
+    if (manifest.routes.some((r) => r.routeData.type === "redirect") && !(used & FetchFeatures.redirects)) {
       missing.push("redirects");
     }
-    if (manifest.sessionConfig && !(used & PipelineFeatures.sessions)) {
+    if (manifest.sessionConfig && !(used & FetchFeatures.sessions)) {
       missing.push("sessions");
     }
-    if (manifest.actions && !(used & PipelineFeatures.actions)) {
+    if (manifest.actions && !(used & FetchFeatures.actions)) {
       missing.push("actions");
     }
-    if (manifest.middleware && !(used & PipelineFeatures.middleware)) {
+    if (manifest.middleware && !(used & FetchFeatures.middleware)) {
       missing.push("middleware");
     }
-    if (manifest.i18n && manifest.i18n.strategy !== "manual" && !(used & PipelineFeatures.i18n)) {
+    if (manifest.i18n && manifest.i18n.strategy !== "manual" && !(used & FetchFeatures.i18n)) {
       missing.push("i18n");
     }
-    if (manifest.cacheConfig && !(used & PipelineFeatures.cache)) {
+    if (manifest.cacheConfig && !(used & FetchFeatures.cache)) {
       missing.push("cache");
     }
     for (const feature of missing) {
       this.logger.warn(
         "router",
-        `Your project uses ${feature}, but your custom src/fetch.ts does not call the ${feature}() handler. This feature will not work unless you add it to your fetch.ts pipeline.`
+        `Your project uses ${feature}, but your custom src/fetch.ts does not call the ${feature}() handler. This feature will not work unless your fetch handler calls it.`
       );
     }
   }
   getDefaultStatusCode(routeData, pathname) {
-    if (!routeData.pattern.test(pathname)) {
-      for (const fallbackRoute of routeData.fallbackRoutes) {
-        if (fallbackRoute.pattern.test(pathname)) {
-          return 302;
-        }
-      }
-    }
-    const route = removeTrailingForwardSlash(routeData.route);
-    const locales = this.manifest.i18n?.locales;
-    if (isRoute404(route) || isLocalizedErrorRoute(route, 404, locales)) {
-      return 404;
-    }
-    if (isRoute500(route) || isLocalizedErrorRoute(route, 500, locales)) {
-      return 500;
-    }
-    return 200;
+    return getDefaultStatusCode(this.manifest, routeData, pathname);
   }
   getManifest() {
-    return this.pipeline.manifest;
+    return this.manifest;
   }
   logThisRequest({
     pathname,

package/dist/core/app/dev-facade.d.ts

@@ -0,0 +1,27 @@
+import type { RouteData } from '../../types/public/index.js';
+import { BaseApp, type DevMatch, type LogRequestPayload } from './base.js';
+import type { SSRManifest } from './types.js';
+/**
+ * The shared thin dev facade: used by BOTH dev paths —
+ * the workerd / non-runnable dev entrypoint (`entrypoints/virtual/dev.ts`)
+ * and the runnable dev server (`vite-plugin-app/createAstroServerApp.ts`).
+ * Everything environment-specific (module loading, error strategy, request
+ * logging behavior) comes from the `RenderEnvironment` record registered on
+ * the manifest before construction, and the runnable dev server's HTTP glue
+ * lives in `vite-plugin-app/handle-request.ts`.
+ */
+export declare class DevFacadeApp extends BaseApp {
+    constructor(manifest: SSRManifest, streaming?: boolean);
+    isDev(): boolean;
+    /** Dev always allows prerendered routes to match. */
+    match(request: Request): RouteData | undefined;
+    /**
+     * A matching route function for the development server. Contrary to
+     * `.match`, this resolves props and params, returning the correct route
+     * based on priority and segments, plus the resolved pathname.
+     */
+    devMatch(pathname?: string, { prerenderOnly }?: {
+        prerenderOnly?: boolean;
+    }): Promise<DevMatch | undefined>;
+    logRequest({ pathname, method, statusCode, isRewrite, reqTime }: LogRequestPayload): void;
+}

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

@@ -0,0 +1,51 @@
+import { req } from "../messages/runtime.js";
+import { matchRoute as devMatchRoute } from "../routing/dev.js";
+import { BaseApp } from "./base.js";
+class DevFacadeApp extends BaseApp {
+  constructor(manifest, streaming = true) {
+    super(manifest, streaming);
+  }
+  isDev() {
+    return true;
+  }
+  /** Dev always allows prerendered routes to match. */
+  match(request) {
+    return super.match(request, true);
+  }
+  /**
+   * A matching route function for the development server. Contrary to
+   * `.match`, this resolves props and params, returning the correct route
+   * based on priority and segments, plus the resolved pathname.
+   */
+  async devMatch(pathname, { prerenderOnly } = {}) {
+    if (pathname === void 0) {
+      return void 0;
+    }
+    const matchedRoute = await devMatchRoute(this.manifest, pathname, { prerenderOnly });
+    if (!matchedRoute) {
+      return void 0;
+    }
+    return {
+      routeData: matchedRoute.route,
+      resolvedPathname: matchedRoute.resolvedPathname
+    };
+  }
+  logRequest({ pathname, method, statusCode, isRewrite, reqTime }) {
+    if (pathname === "/favicon.ico") {
+      return;
+    }
+    this.logger.info(
+      null,
+      req({
+        url: pathname,
+        method,
+        statusCode,
+        isRewrite,
+        reqTime
+      })
+    );
+  }
+}
+export {
+  DevFacadeApp
+};

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

@@ -4,6 +4,5 @@ export { BaseApp, type RenderErrorOptions, type RenderOptions, type LogRequestPa
 export { fromRoutingStrategy, toRoutingStrategy } from '../common.js';
 export { createConsoleLogger } from '../../logger/impls/console.js';
 export { deserializeManifest, deserializeRouteData, deserializeRouteInfo, serializeRouteData, serializeRouteInfo, } from '../manifest.js';
-export { AppPipeline } from '../pipeline.js';
 export { beginContentEntryCollection, endContentEntryCollection, } from '../../build/incremental-content-collector.js';
 export { beginImageCollection, endImageCollection, recordStaticImage, } from '../../build/incremental-image-collector.js';

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

@@ -11,7 +11,6 @@ import {
   serializeRouteData,
   serializeRouteInfo
 } from "../manifest.js";
-import { AppPipeline } from "../pipeline.js";
 import {
   beginContentEntryCollection,
   endContentEntryCollection
@@ -23,7 +22,6 @@ import {
 } from "../../build/incremental-image-collector.js";
 export {
   App,
-  AppPipeline,
   BaseApp,
   beginContentEntryCollection,
   beginImageCollection,

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

@@ -1,40 +1,45 @@
 import fetchable from "virtual:astro:fetchable";
 import { manifest } from "virtual:astro:manifest";
-import { DevApp } from "../../dev/app.js";
+import { clearActions } from "../../../../actions/load.js";
+import { createNonRunnableEnvironment } from "../../../environment/dev-nonrunnable.js";
+import { setEnvironment } from "../../../environment/index.js";
 import { createConsoleLogger } from "../../../logger/impls/console.js";
-let currentDevApp = null;
+import { getLogger, setLogger } from "../../../logger/manifest-logger.js";
+import { clearMiddleware } from "../../../middleware/load.js";
+import { getRouteCache } from "../../../render/route-cache.js";
+import { updateRouteTable } from "../../../routing/route-table.js";
+import { DevFacadeApp } from "../../dev-facade.js";
+let hmrWired = false;
 const createApp = ({ streaming } = {}) => {
-  const logger = createConsoleLogger(manifest.logLevel);
-  currentDevApp = new DevApp(manifest, streaming, logger);
-  currentDevApp.setFetchHandler(fetchable);
-  if (import.meta.hot) {
+  setLogger(manifest, createConsoleLogger(manifest.logLevel));
+  setEnvironment(manifest, createNonRunnableEnvironment());
+  const app = new DevFacadeApp(manifest, streaming);
+  app.setFetchHandler(fetchable);
+  if (import.meta.hot && !hmrWired) {
+    hmrWired = true;
     import.meta.hot.on("astro:routes-updated", async () => {
-      if (!currentDevApp) return;
       try {
         const { routes: newRoutes } = await import("virtual:astro:routes");
-        const newRoutesList = {
-          routes: newRoutes.map((r) => r.routeData)
-        };
-        currentDevApp.updateRoutes(newRoutesList);
+        updateRouteTable(
+          manifest,
+          newRoutes.map((r) => r.routeData)
+        );
       } catch (e) {
-        logger.error("router", `Failed to update routes via HMR:
+        getLogger(manifest).error("router", `Failed to update routes via HMR:
  ${e}`);
       }
     });
     import.meta.hot.on("astro:content-changed", () => {
-      if (!currentDevApp) return;
-      currentDevApp.pipeline.routeCache.clearAll();
+      getRouteCache(manifest).clearAll();
     });
     import.meta.hot.on("astro:middleware-updated", () => {
-      if (!currentDevApp) return;
-      currentDevApp.clearMiddleware();
+      clearMiddleware(manifest);
     });
     import.meta.hot.on("astro:actions-updated", () => {
-      if (!currentDevApp) return;
-      currentDevApp.clearActions();
+      clearActions(manifest);
     });
   }
-  return currentDevApp;
+  return app;
 };
 export {
   createApp

package/dist/core/app/node.js

@@ -19,12 +19,7 @@ function createRequestFromNodeRequest(req, {
   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 url = buildRequestUrl(protocol, hostname, req.url, serverPort);
   const options = {
     method: req.method || "GET",
     headers: makeRequestHeaders(req),
@@ -80,14 +75,7 @@ function createRequest(req, {
   );
   const hostname = validated.host ?? validatedHostname ?? "localhost";
   const port = validated.port ?? (!validated.host && !validatedHostname && serverPort ? String(serverPort) : void 0);
-  let url;
-  try {
-    const hostnamePort = getHostnamePort(hostname, port);
-    url = new URL(`${protocol}://${hostnamePort}${req.url}`);
-  } catch {
-    const hostnamePort = getHostnamePort(hostname, port);
-    url = new URL(`${protocol}://${hostnamePort}`);
-  }
+  const url = buildRequestUrl(protocol, getHostnamePort(hostname, port), req.url, serverPort);
   const options = {
     method: req.method || "GET",
     headers: makeRequestHeaders(req),
@@ -245,6 +233,17 @@ function getHostnamePort(hostname, port) {
   const hostnamePort = portInHostname ? hostname : `${hostname}${port ? `:${port}` : ""}`;
   return hostnamePort;
 }
+function buildRequestUrl(protocol, hostnamePort, requestPath, serverPort) {
+  const path = requestPath ?? "";
+  if (URL.canParse(`${protocol}://${hostnamePort}${path}`)) {
+    return new URL(`${protocol}://${hostnamePort}${path}`);
+  }
+  if (URL.canParse(`${protocol}://${hostnamePort}`)) {
+    return new URL(`${protocol}://${hostnamePort}`);
+  }
+  const fallbackHost = serverPort ? `localhost:${serverPort}` : "localhost";
+  return new URL(`${protocol}://${fallbackHost}`);
+}
 function makeRequestHeaders(req) {
   const headers = new Headers();
   for (const [name, value] of Object.entries(req.headers)) {

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

@@ -3,7 +3,7 @@
  * and marks the response as sent.
  *
  * This is a pure function with no dependencies on the app; it is shared by
- * `AstroHandler` and the various error handlers.
+ * `handleRequest` and the various error handlers.
  */
 export declare function prepareResponse(response: Response, { addCookieHeader }: {
     addCookieHeader: boolean;

package/dist/core/app/validate-headers.js

@@ -9,6 +9,7 @@ function sanitizeHost(hostname) {
 }
 function parseHost(host) {
   const parts = host.split(":");
+  if (parts.length > 2) return void 0;
   return {
     hostname: parts[0],
     port: parts[1]
@@ -28,7 +29,9 @@ function validateHost(host, protocol, allowedDomains) {
   if (!allowedDomains || allowedDomains.length === 0) return void 0;
   const sanitized = sanitizeHost(host);
   if (!sanitized) return void 0;
-  const { hostname, port } = parseHost(sanitized);
+  const parsed = parseHost(sanitized);
+  if (!parsed) return void 0;
+  const { hostname, port } = parsed;
   if (matchesAllowedDomains(hostname, protocol, port, allowedDomains)) {
     return sanitized;
   }
@@ -67,8 +70,9 @@ function validateForwardedHeaders(forwardedProtocol, forwardedHost, forwardedPor
   if (forwardedHost && forwardedHost.length > 0 && allowedDomains && allowedDomains.length > 0) {
     const protoForValidation = result.protocol || "https";
     const sanitized = sanitizeHost(forwardedHost);
-    if (sanitized) {
-      const { hostname, port: portFromHost } = parseHost(sanitized);
+    const parsed = sanitized ? parseHost(sanitized) : void 0;
+    if (sanitized && parsed) {
+      const { hostname, port: portFromHost } = parsed;
       const portForValidation = result.port || portFromHost;
       if (matchesAllowedDomains(hostname, protoForValidation, portForValidation, allowedDomains)) {
         result.host = sanitized;

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

@@ -1,17 +1,42 @@
 import { BaseApp } from '../app/entrypoints/index.js';
+import type { LogRequestPayload } from '../app/base.js';
 import type { SSRManifest } from '../app/types.js';
+import type { ComponentInstance } from '../../types/astro.js';
+import type { RouteData } from '../../types/public/internal.js';
+import { type RouteCache } from '../render/route-cache.js';
+import type { BuildEnvironmentSlots } from './environment.js';
 import type { BuildInternals } from './internal.js';
-import { BuildPipeline } from './pipeline.js';
 import type { StaticBuildOptions } from './types.js';
-import type { LogRequestPayload } from '../app/base.js';
-import type { ErrorHandler } from '../errors/handler.js';
-export declare class BuildApp extends BaseApp<BuildPipeline> {
-    createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
+/**
+ * The build / prerender facade: a thin shell over the
+ * build environment record. The two-phase init state (`setInternals` /
+ * `setOptions`, injected by `createDefaultPrerenderer.setup()` after the
+ * prerender bundle import) lives in the `BuildEnvironmentSlots` closure
+ * created by the prerender entrypoint; the facade only forwards across the
+ * bundle boundary into those slots.
+ */
+export declare class BuildApp extends BaseApp {
+    #private;
+    constructor(manifest: SSRManifest, buildEnv: BuildEnvironmentSlots);
     isDev(): boolean;
+    /**
+     * Streaming falls through to the environment default
+     * (`manifest.serverLike` for the build environment) — we can skip
+     * streaming in SSG for performance, as writing strings is faster.
+     */
+    protected resolveStreaming(): boolean | undefined;
     setInternals(internals: BuildInternals): void;
     setOptions(options: StaticBuildOptions): void;
     getOptions(): StaticBuildOptions;
     getSettings(): import("../../types/astro.js").AstroSettings;
-    protected createErrorHandler(): ErrorHandler;
+    /**
+     * Route cache and component loader for `StaticPaths`. Defined on the app
+     * (rather than reached through the functional core at the call site) so
+     * they execute inside the prerender bundle's module graph: the default
+     * prerenderer constructs `StaticPaths` from a different bundle, whose
+     * copies of the core modules hold separate per-manifest state.
+     */
+    get routeCache(): RouteCache;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
     logRequest(_options: LogRequestPayload): void;
 }

package/dist/core/build/app.js

@@ -1,31 +1,49 @@
 import { BaseApp } from "../app/entrypoints/index.js";
-import { BuildPipeline } from "./pipeline.js";
-import { BuildErrorHandler } from "../errors/build-handler.js";
+import { getEnvironment } from "../environment/index.js";
+import { getRouteCache } from "../render/route-cache.js";
 class BuildApp extends BaseApp {
-  createPipeline(_streaming, manifest, ..._args) {
-    return BuildPipeline.create({
-      manifest
-    });
+  #buildEnv;
+  constructor(manifest, buildEnv) {
+    super(manifest);
+    this.#buildEnv = buildEnv;
   }
   isDev() {
     return true;
   }
+  /**
+   * Streaming falls through to the environment default
+   * (`manifest.serverLike` for the build environment) — we can skip
+   * streaming in SSG for performance, as writing strings is faster.
+   */
+  resolveStreaming() {
+    return void 0;
+  }
   setInternals(internals) {
-    this.pipeline.setInternals(internals);
+    this.#buildEnv.setInternals(internals);
   }
   setOptions(options) {
-    this.pipeline.setOptions(options);
+    this.#buildEnv.setOptions(options);
     this.logger.setDestination(options.logger.options.destination);
     this.resetAdapterLogger();
   }
   getOptions() {
-    return this.pipeline.getOptions();
+    return this.#buildEnv.getOptions();
   }
   getSettings() {
-    return this.pipeline.getSettings();
-  }
-  createErrorHandler() {
-    return new BuildErrorHandler(this);
+    return this.#buildEnv.getSettings();
+  }
+  /**
+   * Route cache and component loader for `StaticPaths`. Defined on the app
+   * (rather than reached through the functional core at the call site) so
+   * they execute inside the prerender bundle's module graph: the default
+   * prerenderer constructs `StaticPaths` from a different bundle, whose
+   * copies of the core modules hold separate per-manifest state.
+   */
+  get routeCache() {
+    return getRouteCache(this.manifest);
+  }
+  getComponentByRoute(routeData) {
+    return getEnvironment(this.manifest).getComponentByRoute(this.manifest, routeData);
   }
   logRequest(_options) {
   }

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

@@ -0,0 +1,25 @@
+import type { AstroSettings } from '../../types/astro.js';
+import type { RenderEnvironment } from '../environment/index.js';
+import type { BuildInternals } from './internal.js';
+import type { StaticBuildOptions } from './types.js';
+/**
+ * The build / prerender environment record and its mutable closure slots.
+ * The build has a two-phase initialization: the prerender bundle is imported
+ * first, and `createDefaultPrerenderer.setup()` injects `BuildInternals` /
+ * `StaticBuildOptions` afterwards through the facade. The slots live in this
+ * closure; accessors throw before injection, and the environment functions
+ * close over the same slots.
+ */
+export interface BuildEnvironmentSlots {
+    /** The build `RenderEnvironment`; its functions close over the slots below. */
+    env: RenderEnvironment;
+    setInternals(internals: BuildInternals): void;
+    setOptions(options: StaticBuildOptions): void;
+    /** Throws `No internals defined` before injection. */
+    getInternals(): BuildInternals;
+    /** Throws `No options defined` before injection. */
+    getOptions(): StaticBuildOptions;
+    /** Throws `No options defined` before injection. */
+    getSettings(): AstroSettings;
+}
+export declare function createBuildEnvironment(): BuildEnvironmentSlots;