astro 7.2.2 → 7.2.3

package/dist/core/build/environment.js

@@ -0,0 +1,157 @@
+import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
+import { createAssetLink, createStylesheetElementSet } from "../render/ssr-element.js";
+import { getDefaultRoutes } from "../routing/default.js";
+import { getFallbackRoute, routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
+import { cssOrder, getPageData, mergeInlineCss } from "./runtime.js";
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  let routeToProcess = route;
+  if (routeIsRedirect(route)) {
+    if (route.redirectRoute) {
+      routeToProcess = route.redirectRoute;
+    } else {
+      return RedirectSinglePageBuiltModule;
+    }
+  } else if (routeIsFallback(route)) {
+    routeToProcess = getFallbackRoute(route, manifest.routes);
+  }
+  if (manifest.pageMap) {
+    const importComponentInstance = manifest.pageMap.get(routeToProcess.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."
+  );
+}
+async function getComponentByRoute(manifest, routeData) {
+  const module = await getModuleForRoute(manifest, routeData);
+  return module.page();
+}
+function createBuildEnvironment() {
+  let internals;
+  let options;
+  function getInternals() {
+    if (!internals) {
+      throw new Error("No internals defined");
+    }
+    return internals;
+  }
+  function getOptions() {
+    if (!options) {
+      throw new Error("No options defined");
+    }
+    return options;
+  }
+  function getSettings() {
+    return getOptions().settings;
+  }
+  const resolveCache = /* @__PURE__ */ new Map();
+  const env = {
+    name: "build",
+    runtimeMode: "production",
+    // We can skip streaming in SSG for performance as writing as strings is
+    // faster.
+    defaultStreaming: (manifest) => manifest.serverLike,
+    async resolve(manifest, specifier) {
+      if (resolveCache.has(specifier)) {
+        return resolveCache.get(specifier);
+      }
+      const hashedFilePath = manifest.entryModules[specifier];
+      if (typeof hashedFilePath !== "string" || hashedFilePath === "") {
+        if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
+          resolveCache.set(specifier, "");
+          return "";
+        }
+        throw new Error(`Cannot find the built path for ${specifier}`);
+      }
+      const assetLink = createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
+      resolveCache.set(specifier, assetLink);
+      return assetLink;
+    },
+    headElements(manifest, routeData) {
+      const { assetsPrefix, base } = manifest;
+      const settings = getSettings();
+      const buildInternals = getInternals();
+      const links = /* @__PURE__ */ new Set();
+      const pageBuildData = getPageData(buildInternals, routeData.route, routeData.component);
+      const scripts = /* @__PURE__ */ new Set();
+      const sortedCssAssets = pageBuildData?.styles.sort(cssOrder).map(({ sheet }) => sheet).reduce(mergeInlineCss, []);
+      const styles = createStylesheetElementSet(sortedCssAssets ?? [], base, assetsPrefix);
+      if (settings.scripts.some((script) => script.stage === "page")) {
+        const hashedFilePath = buildInternals.entrySpecifierToBundleMap.get(PAGE_SCRIPT_ID);
+        if (typeof hashedFilePath !== "string") {
+          throw new Error(`Cannot find the built path for ${PAGE_SCRIPT_ID}`);
+        }
+        const src = createAssetLink(hashedFilePath, base, assetsPrefix);
+        scripts.add({
+          props: { type: "module", src },
+          children: ""
+        });
+      }
+      for (const script of settings.scripts) {
+        if (script.stage === "head-inline") {
+          scripts.add({
+            props: {},
+            children: script.content
+          });
+        }
+      }
+      return { scripts, styles, links };
+    },
+    componentMetadata() {
+    },
+    getComponentByRoute,
+    getModuleForRoute,
+    async tryRewrite(manifest, payload, request) {
+      const { routeData, pathname, newUrl } = findRouteToRewrite({
+        payload,
+        request,
+        // RAW manifest routes, exactly like `BuildPipeline.tryRewrite` — see
+        // the production environment's tryRewrite for why the derived
+        // (ensured-404) table is NOT observably identical here.
+        routes: manifest.routes.map((r) => r.routeData),
+        trailingSlash: manifest.trailingSlash,
+        buildFormat: manifest.buildFormat,
+        base: manifest.base,
+        outDir: manifest.serverLike ? manifest.buildClientDir : manifest.outDir
+      });
+      const componentInstance = await getComponentByRoute(manifest, routeData);
+      return { routeData, componentInstance, newUrl, pathname };
+    },
+    getRenderers(manifest) {
+      return manifest.renderers;
+    },
+    errorStrategy: "build",
+    injectCspMetaTagsOnErrorPages: false,
+    logRequest() {
+    }
+  };
+  return {
+    env,
+    setInternals(value) {
+      internals = value;
+    },
+    setOptions(value) {
+      options = value;
+    },
+    getInternals,
+    getOptions,
+    getSettings
+  };
+}
+export {
+  createBuildEnvironment
+};

package/dist/core/cache/handler.d.ts

@@ -1,6 +1,6 @@
-import type { BaseApp } from '../app/base.js';
 import type { FetchState } from '../fetch/fetch-state.js';
-import type { Pipeline } from '../base-pipeline.js';
+import type { SSRManifest } from '../app/types.js';
+import { type CompiledCacheRoute } from './runtime/route-matching.js';
 /**
  * Registers a cache provider on the given `FetchState`. When
  * `state.resolve('cache')` is first called, the appropriate cache
@@ -22,8 +22,14 @@ export declare function provideCache(state: FetchState): Promise<void> | void;
  * Cache headers (`CDN-Cache-Control`, `Cache-Tag`) are stripped from
  * the final response after the runtime provider has read them.
  */
-export declare class CacheHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>);
-    handle(state: FetchState, next: () => Promise<Response>): Promise<Response>;
-}
+export declare function handleCache(state: FetchState, next: () => Promise<Response>): Promise<Response>;
+/**
+ * Config-level cache routes compiled from `manifest.cacheConfig`, derived
+ * lazily on the first cache-seeded request.
+ */
+export declare function getCompiledCacheRoutes(manifest: SSRManifest): CompiledCacheRoute[];
+/**
+ * Internal raw setter — exists only so the transitional `Pipeline` bridge can
+ * expose `compiledCacheRoutes` as a get/set pair.
+ */
+export declare function setCompiledCacheRoutes(manifest: SSRManifest, routes: CompiledCacheRoute[]): void;

package/dist/core/cache/handler.js

@@ -1,38 +1,37 @@
-import { PipelineFeatures } from "../base-pipeline.js";
+import { markFeatureUsed, FetchFeatures } from "../fetch/features.js";
+import { getEnvironment } from "../environment/index.js";
+import { createManifestMemo } from "../manifest/memo.js";
+import { getCacheProvider } from "./provider.js";
 import { AstroCache, applyCacheHeaders } from "./runtime/cache.js";
 import { NoopAstroCache, DisabledAstroCache } from "./runtime/noop.js";
-import { compileCacheRoutes, matchCacheRoute } from "./runtime/route-matching.js";
+import {
+  compileCacheRoutes,
+  matchCacheRoute
+} from "./runtime/route-matching.js";
 const CACHE_KEY = "cache";
 function provideCache(state) {
-  const pipeline = state.pipeline;
-  if (!pipeline.cacheConfig) {
+  const manifest = state.manifest;
+  if (!manifest.cacheConfig) {
     state.provide(CACHE_KEY, {
-      create: () => new DisabledAstroCache(pipeline.logger)
+      create: () => new DisabledAstroCache(state.logger)
     });
     return;
   }
-  if (pipeline.runtimeMode === "development") {
+  if (getEnvironment(manifest).runtimeMode === "development") {
     state.provide(CACHE_KEY, {
       create: () => new NoopAstroCache()
     });
     return;
   }
-  return provideCacheAsync(state, pipeline);
+  return provideCacheAsync(state, manifest);
 }
-async function provideCacheAsync(state, pipeline) {
-  const cacheProvider = await pipeline.getCacheProvider();
+async function provideCacheAsync(state, manifest) {
+  const cacheProvider = await getCacheProvider(manifest);
   state.provide(CACHE_KEY, {
     create() {
       const cache = new AstroCache(cacheProvider);
-      if (pipeline.cacheConfig?.routes) {
-        if (!pipeline.compiledCacheRoutes) {
-          pipeline.compiledCacheRoutes = compileCacheRoutes(
-            pipeline.cacheConfig.routes,
-            pipeline.manifest.base,
-            pipeline.manifest.trailingSlash
-          );
-        }
-        const matched = matchCacheRoute(state.pathname, pipeline.compiledCacheRoutes);
+      if (manifest.cacheConfig?.routes) {
+        const matched = matchCacheRoute(state.pathname, getCompiledCacheRoutes(manifest));
         if (matched) {
           cache.set(matched);
         }
@@ -41,41 +40,46 @@ async function provideCacheAsync(state, pipeline) {
     }
   });
 }
-class CacheHandler {
-  #app;
-  constructor(app) {
-    this.#app = app;
+async function handleCache(state, next) {
+  markFeatureUsed(state.manifest, FetchFeatures.cache);
+  if (!state.manifest.cacheProvider) {
+    return next();
   }
-  async handle(state, next) {
-    this.#app.pipeline.usedFeatures |= PipelineFeatures.cache;
-    if (!this.#app.pipeline.cacheProvider) {
-      return next();
-    }
-    const cache = state.resolve(CACHE_KEY);
-    const cacheProvider = await this.#app.pipeline.getCacheProvider();
-    if (cacheProvider?.onRequest) {
-      const response2 = await cacheProvider.onRequest(
-        {
-          request: state.request,
-          url: new URL(state.request.url),
-          waitUntil: state.renderOptions.waitUntil
-        },
-        async () => {
-          const res = await next();
-          applyCacheHeaders(cache, res, state.request);
-          return res;
-        }
-      );
-      response2.headers.delete("CDN-Cache-Control");
-      response2.headers.delete("Cache-Tag");
-      return response2;
-    }
-    const response = await next();
-    applyCacheHeaders(cache, response, state.request);
-    return response;
+  const cache = state.resolve(CACHE_KEY);
+  const cacheProvider = await getCacheProvider(state.manifest);
+  if (cacheProvider?.onRequest) {
+    const response2 = await cacheProvider.onRequest(
+      {
+        request: state.request,
+        url: new URL(state.request.url),
+        waitUntil: state.renderOptions.waitUntil
+      },
+      async () => {
+        const res = await next();
+        applyCacheHeaders(cache, res, state.request);
+        return res;
+      }
+    );
+    response2.headers.delete("CDN-Cache-Control");
+    response2.headers.delete("Cache-Tag");
+    return response2;
   }
+  const response = await next();
+  applyCacheHeaders(cache, response, state.request);
+  return response;
+}
+const compiledCacheRoutesMemo = createManifestMemo(
+  (manifest) => manifest.cacheConfig?.routes ? compileCacheRoutes(manifest.cacheConfig.routes, manifest.base, manifest.trailingSlash) : []
+);
+function getCompiledCacheRoutes(manifest) {
+  return compiledCacheRoutesMemo.get(manifest);
+}
+function setCompiledCacheRoutes(manifest, routes) {
+  compiledCacheRoutesMemo.set(manifest, routes);
 }
 export {
-  CacheHandler,
-  provideCache
+  getCompiledCacheRoutes,
+  handleCache,
+  provideCache,
+  setCompiledCacheRoutes
 };

package/dist/core/cache/provider.d.ts

@@ -0,0 +1,4 @@
+import type { SSRManifest } from '../app/types.js';
+import type { CacheProvider } from './types.js';
+/** Resolves the cache provider from the manifest, `null` when none. */
+export declare function getCacheProvider(manifest: SSRManifest): Promise<CacheProvider | null>;

package/dist/core/cache/provider.js

@@ -0,0 +1,15 @@
+import { createAsyncManifestMemo } from "../manifest/memo.js";
+const cacheProviderMemo = createAsyncManifestMemo(async (manifest) => {
+  if (manifest.cacheProvider) {
+    const mod = await manifest.cacheProvider();
+    const factory = mod?.default || null;
+    return factory ? factory(manifest.cacheConfig?.options) : null;
+  }
+  return null;
+});
+function getCacheProvider(manifest) {
+  return cacheProviderMemo.get(manifest);
+}
+export {
+  getCacheProvider
+};

package/dist/core/constants.d.ts

@@ -32,10 +32,6 @@ export declare const clientLocalsSymbol: unique symbol;
  * Use this symbol to set and retrieve the original pathname of a request. This is useful when working with redirects and rewrites
  */
 export declare const originPathnameSymbol: unique symbol;
-/**
- * Use this symbol to set and retrieve the pipeline.
- */
-export declare const pipelineSymbol: unique symbol;
 /**
  * Use this symbol to stash the active `FetchState` on an `APIContext`
  * (or `ActionAPIContext`). Consumed by internal shims that need access
@@ -44,13 +40,6 @@ export declare const pipelineSymbol: unique symbol;
  * `src/i18n/middleware.ts`.
  */
 export declare const fetchStateSymbol: unique symbol;
-/**
- * Use this symbol to stash the `BaseApp` on an incoming `Request` at the
- * top of the pipeline. Fetch handlers loaded from `virtual:astro:fetchable`
- * (including `DefaultFetchHandler`) read it to find the app associated
- * with the current request without needing App passed to their constructor.
- */
-export declare const appSymbol: unique symbol;
 /**
  * Use this symbol to opt into handling prerender routes in Astro core dev middleware.
  */

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.2.2";
+const ASTRO_VERSION = "7.2.3";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";
@@ -7,9 +7,7 @@ const REROUTABLE_STATUS_CODES = [404, 500];
 const clientAddressSymbol = /* @__PURE__ */ Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = /* @__PURE__ */ Symbol.for("astro.locals");
 const originPathnameSymbol = /* @__PURE__ */ Symbol.for("astro.originPathname");
-const pipelineSymbol = /* @__PURE__ */ Symbol.for("astro.pipeline");
 const fetchStateSymbol = /* @__PURE__ */ Symbol.for("astro.fetchState");
-const appSymbol = /* @__PURE__ */ Symbol.for("astro.app");
 const devPrerenderMiddlewareSymbol = /* @__PURE__ */ Symbol.for("astro.devPrerenderMiddleware");
 const nodeRequestAbortControllerCleanupSymbol = /* @__PURE__ */ Symbol.for(
   "astro.nodeRequestAbortControllerCleanup"
@@ -50,13 +48,11 @@ export {
   REDIRECT_STATUS_CODES,
   REROUTABLE_STATUS_CODES,
   SUPPORTED_MARKDOWN_FILE_EXTENSIONS,
-  appSymbol,
   clientAddressSymbol,
   clientLocalsSymbol,
   devPrerenderMiddlewareSymbol,
   fetchStateSymbol,
   nodeRequestAbortControllerCleanupSymbol,
   originPathnameSymbol,
-  pipelineSymbol,
   responseSentSymbol
 };

package/dist/core/dev/dev.js

@@ -26,7 +26,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "7.2.2";
+  const currentVersion = "7.2.3";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/environment/dev-nonrunnable.d.ts

@@ -0,0 +1,6 @@
+import type { RenderEnvironment } from './index.js';
+/**
+ * The non-runnable dev environment (workerd and other adapters whose requests
+ * run outside Vite's module runner). Registered by the dev virtual entrypoint.
+ */
+export declare function createNonRunnableEnvironment(): RenderEnvironment;

package/dist/core/environment/dev-nonrunnable.js

@@ -0,0 +1,170 @@
+import { stringifyForScript } from "../../runtime/server/escape.js";
+import { ASTRO_VERSION } from "../constants.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { req } from "../messages/runtime.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
+import { createModuleScriptElement, createStylesheetElementSet } from "../render/ssr-element.js";
+import { getDefaultRoutes } from "../routing/default.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
+import { getRouteTable } from "../routing/route-table.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."
+    );
+  }
+}
+async function getComponentByRoute(manifest, routeData) {
+  try {
+    const module2 = await getModuleForRoute(manifest, routeData);
+    return module2.page();
+  } catch {
+  }
+  const url = new URL(routeData.component, manifest.rootDir);
+  const module = await import(
+    /* @vite-ignore */
+    url.toString()
+  );
+  return module;
+}
+function createNonRunnableEnvironment() {
+  return {
+    name: "dev-nonrunnable",
+    runtimeMode: "development",
+    // Dev always streams.
+    defaultStreaming: () => true,
+    async resolve(_manifest, specifier) {
+      if (specifier.startsWith("/")) {
+        return specifier;
+      } else {
+        return "/@id/" + specifier;
+      }
+    },
+    async headElements(manifest, routeData) {
+      const { componentMetadataEntries } = await import("virtual:astro:component-metadata");
+      for (const [id, entry] of componentMetadataEntries) {
+        manifest.componentMetadata.set(id, entry);
+      }
+      const { assetsPrefix, base } = manifest;
+      const routeInfo = manifest.routes.find((route) => route.routeData === routeData);
+      const links = /* @__PURE__ */ new Set();
+      const scripts = /* @__PURE__ */ new Set();
+      const styles = createStylesheetElementSet(routeInfo?.styles ?? [], base, assetsPrefix);
+      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));
+        }
+      }
+      scripts.add({
+        props: { type: "module", src: "/@vite/client" },
+        children: ""
+      });
+      if (manifest.devToolbar.enabled) {
+        scripts.add({
+          props: {
+            type: "module",
+            src: "/@id/astro/runtime/client/dev-toolbar/entrypoint.js"
+          },
+          children: ""
+        });
+        const additionalMetadata = {
+          root: manifest.rootDir.toString(),
+          version: ASTRO_VERSION,
+          latestAstroVersion: manifest.devToolbar.latestAstroVersion,
+          debugInfo: manifest.devToolbar.debugInfoOutput ?? "",
+          placement: manifest.devToolbar.placement
+        };
+        const children = `window.__astro_dev_toolbar__ = ${stringifyForScript(additionalMetadata)}`;
+        scripts.add({ props: {}, children });
+      }
+      const { devCSSMap } = await import("virtual:astro:dev-css-all");
+      const importer = devCSSMap.get(routeData.component);
+      let css = /* @__PURE__ */ new Set();
+      if (importer) {
+        const cssModule = await importer();
+        css = cssModule.css;
+      } else {
+        getLogger(manifest).warn(
+          "assets",
+          `Unable to find CSS for ${routeData.component}. This is likely a bug in Astro.`
+        );
+      }
+      for (const { id, url: src, content } of css) {
+        scripts.add({ props: { type: "module", src }, children: "" });
+        styles.add({ props: { "data-vite-dev-id": id }, children: content });
+      }
+      return { scripts, styles, links };
+    },
+    componentMetadata() {
+    },
+    getComponentByRoute,
+    getModuleForRoute,
+    async tryRewrite(manifest, payload, request) {
+      const { newUrl, pathname, routeData } = findRouteToRewrite({
+        payload,
+        request,
+        // The single fresh route table: HMR route updates are visible
+        // to rewrites at the same instant as every other consumer.
+        routes: getRouteTable(manifest).routes,
+        trailingSlash: manifest.trailingSlash,
+        buildFormat: manifest.buildFormat,
+        base: manifest.base,
+        outDir: manifest.serverLike ? manifest.buildClientDir : manifest.outDir
+      });
+      const componentInstance = await getComponentByRoute(manifest, routeData);
+      return { newUrl, pathname, componentInstance, routeData };
+    },
+    getRenderers(manifest) {
+      return manifest.renderers;
+    },
+    errorStrategy: "dev",
+    injectCspMetaTagsOnErrorPages: false,
+    logRequest(manifest, payload) {
+      const { pathname, method, statusCode, isRewrite, timeStart } = payload;
+      if (pathname === "/favicon.ico") {
+        return;
+      }
+      const reqTime = performance.now() - timeStart;
+      getLogger(manifest).info(
+        null,
+        req({
+          url: pathname,
+          method,
+          statusCode,
+          isRewrite,
+          reqTime
+        })
+      );
+    }
+  };
+}
+export {
+  createNonRunnableEnvironment
+};

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

@@ -0,0 +1,90 @@
+import type { ComponentInstance } from '../../types/astro.js';
+import type { RewritePayload } from '../../types/public/common.js';
+import type { RuntimeMode } from '../../types/public/config.js';
+import type { RouteData, SSRLoadedRenderer, SSRManifest, SSRResult } from '../../types/public/internal.js';
+import type { LogRequestPayload } from '../app/base.js';
+import type { SinglePageBuiltModule } from '../build/types.js';
+/**
+ * The scripts, styles and links a rendering environment injects into a page's
+ * head for a given route. (Rehomed here from the deleted Pipeline base class.)
+ */
+export interface HeadElements extends Pick<SSRResult, 'scripts' | 'styles' | 'links'> {
+}
+/**
+ * The result of a successful `tryRewrite` environment call.
+ * (Rehomed here from the deleted Pipeline base class.)
+ */
+export interface TryRewriteResult {
+    routeData: RouteData;
+    componentInstance: ComponentInstance;
+    newUrl: URL;
+    pathname: string;
+}
+/**
+ * The payload chain sites pass to request logging (`logRequestFromState`).
+ * `reqTime` is computed by the receiver (facade `logThisRequest` or the env
+ * record) from `timeStart`.
+ */
+export type RequestLogPayload = Omit<LogRequestPayload, 'reqTime'> & {
+    timeStart: number;
+};
+/**
+ * The behavior that varies between rendering environments (production SSR,
+ * the two dev paths, build/prerender, the container), expressed as a plain
+ * record of functions and flags instead of a class hierarchy. Environments
+ * register their record for a manifest with `setEnvironment`; readers use
+ * `getEnvironment`, which falls back to the production record.
+ *
+ * When adding a member:
+ * - Only behavior that genuinely differs between environments belongs here
+ *   (e.g. request logging: production is silent, dev prints request lines).
+ *   If the build can emit it as data or a module thunk, put it on the
+ *   manifest instead; only behavior needing live services goes here.
+ * - The record is stateless and shared. Mutable per-app state belongs in a
+ *   manifest-keyed memo in the module that owns it, not here.
+ * - Members must not capture an App instance. Environment-private services
+ *   captured at setup time (the dev ModuleLoader, BuildInternals) are fine —
+ *   request handling can't reach them.
+ * - Behavior tied to one App instance — a public method a user may override
+ *   on their app — cannot live here, because the record is shared by every
+ *   app in the environment. The facade forwards that per request, via the
+ *   hooks it passes to the FetchState constructor.
+ */
+export interface RenderEnvironment {
+    /** Debug label. */
+    readonly name: string;
+    readonly runtimeMode: RuntimeMode;
+    /** Default streaming when the facade hooks don't specify a flag. */
+    defaultStreaming(manifest: SSRManifest): boolean;
+    resolve(manifest: SSRManifest, specifier: string): Promise<string>;
+    headElements(manifest: SSRManifest, routeData: RouteData): Promise<HeadElements> | HeadElements;
+    componentMetadata(manifest: SSRManifest, routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
+    getComponentByRoute(manifest: SSRManifest, routeData: RouteData): Promise<ComponentInstance>;
+    getModuleForRoute(manifest: SSRManifest, route: RouteData): Promise<SinglePageBuiltModule>;
+    tryRewrite(manifest: SSRManifest, payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
+    /** Renderers for `createResult`. Sync — render sites read it without awaiting. */
+    getRenderers(manifest: SSRManifest): SSRLoadedRenderer[];
+    /** Which error-page strategy `renderErrorPage` dispatches to. */
+    readonly errorStrategy: 'default' | 'dev' | 'build';
+    /** Dev-only CSP meta-tag injection flag for error pages. */
+    readonly injectCspMetaTagsOnErrorPages: boolean;
+    /**
+     * Request logging as environment behavior: prod/build/container are
+     * no-ops; both dev environments emit the request lines. This is the
+     * fallback for states not built by a facade; the facade fast path's
+     * `hooks.logRequest` takes precedence so subclass overrides keep working.
+     * Computes `reqTime` from `payload.timeStart`.
+     */
+    logRequest(manifest: SSRManifest, payload: RequestLogPayload): void;
+}
+/**
+ * Registers the environment for a manifest. Idempotent; last registration wins
+ * (build may re-register after internals/options injection if it prefers).
+ */
+export declare function setEnvironment(manifest: SSRManifest, env: RenderEnvironment): void;
+/**
+ * The environment for a manifest. Defaults to the production (bundled)
+ * implementation, which is derivable from the manifest alone — so a bare
+ * `new FetchState(request)` in a bundled worker needs no registration.
+ */
+export declare function getEnvironment(manifest: SSRManifest): RenderEnvironment;