astro 7.2.1 → 7.2.3

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.1";
+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.1";
+  const currentVersion = "7.2.3";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/dev/lockfile.d.ts

@@ -32,6 +32,22 @@ export declare function serializeLockFile(data: LockFileData): string;
  * Signal 0 does not kill the process — it only checks whether the process exists.
  */
 export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Check whether a process command points to the Astro CLI.
+ */
+export declare function isAstroCommand(command: string): boolean;
+interface ProcessInfo {
+    pid: number;
+    cmd?: string;
+}
+type ProcessLookup = (by: 'pid', value: number, options: {
+    logLevel: 'error';
+}) => Promise<ProcessInfo[]>;
+/**
+ * Check whether the live process recorded in a lock file is still Astro.
+ * If the command cannot be inspected, keep the existing PID-only behavior.
+ */
+export declare function isLockFileProcessAlive(data: LockFileData, find?: ProcessLookup): Promise<boolean>;
 /**
  * Read the lock file from disk. Returns null if it doesn't exist or is invalid.
  */
@@ -58,8 +74,9 @@ export declare function evaluateExistingServer(data: LockFileData | null, alive:
  */
 export declare function killDevServer(root: URL, data: LockFileData): Promise<void>;
 /**
- * Check for an existing server by reading the lock file and checking process liveness.
+ * Check for an existing server by reading the lock file and checking process identity.
  * Automatically cleans up stale lock files.
  * Returns the server info if a live server is found, null otherwise.
  */
-export declare function checkExistingServer(root: URL, command?: ServerCommand): LockFileData | null;
+export declare function checkExistingServer(root: URL, command?: ServerCommand): Promise<LockFileData | null>;
+export {};

package/dist/core/dev/lockfile.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import findProcess from "find-process";
 const GRACEFUL_SHUTDOWN_TIMEOUT = 5e3;
 function getLockFileURL(root, command = "dev") {
   return new URL(`.astro/${command}.json`, root);
@@ -42,6 +43,23 @@ function isProcessAlive(pid) {
     return false;
   }
 }
+const ASTRO_COMMAND_PATTERN = /(?:^|[\\/\s"'])(?:astro[\\/]bin[\\/]astro\.mjs|\.bin[\\/]astro(?:\.cmd)?)(?=$|[\s"'])/i;
+function isAstroCommand(command) {
+  return ASTRO_COMMAND_PATTERN.test(command);
+}
+async function isLockFileProcessAlive(data, find = findProcess) {
+  if (!isProcessAlive(data.pid)) {
+    return false;
+  }
+  try {
+    const processInfo = (await find("pid", data.pid, { logLevel: "error" })).find(
+      ({ pid }) => pid === data.pid
+    );
+    return processInfo?.cmd === void 0 || isAstroCommand(processInfo.cmd);
+  } catch {
+    return true;
+  }
+}
 function readLockFile(root, command = "dev") {
   const lockFileURL = getLockFileURL(root, command);
   try {
@@ -98,9 +116,12 @@ async function killDevServer(root, data) {
   }
   removeLockFile(root);
 }
-function checkExistingServer(root, command = "dev") {
+async function checkExistingServer(root, command = "dev") {
   const data = readLockFile(root, command);
-  const result = evaluateExistingServer(data, data !== null && isProcessAlive(data.pid));
+  const result = evaluateExistingServer(
+    data,
+    data !== null && await isLockFileProcessAlive(data)
+  );
   if (result === null) {
     return null;
   }
@@ -115,6 +136,8 @@ export {
   checkExistingServer,
   evaluateExistingServer,
   getLogFileURL,
+  isAstroCommand,
+  isLockFileProcessAlive,
   isProcessAlive,
   killDevServer,
   parseLockFile,

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;

package/dist/core/environment/index.js

@@ -0,0 +1,12 @@
+import { productionEnvironment } from "./production.js";
+const environments = /* @__PURE__ */ new WeakMap();
+function setEnvironment(manifest, env) {
+  environments.set(manifest, env);
+}
+function getEnvironment(manifest) {
+  return environments.get(manifest) ?? productionEnvironment;
+}
+export {
+  getEnvironment,
+  setEnvironment
+};

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

@@ -0,0 +1,6 @@
+import type { RenderEnvironment } from './index.js';
+/**
+ * The production / bundled environment — the default when nothing is
+ * registered. A stateless module constant derived from the manifest alone.
+ */
+export declare const productionEnvironment: RenderEnvironment;