astro 4.4.0 → 4.4.1

package/dist/core/endpoint/index.js

@@ -1,16 +1,10 @@
-import { renderEndpoint } from "../../runtime/server/index.js";
-import { ASTRO_VERSION } from "../constants.js";
-import { AstroCookies, attachCookiesToResponse } from "../cookies/index.js";
+import { ASTRO_VERSION, clientAddressSymbol, clientLocalsSymbol } from "../constants.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
-import { callMiddleware } from "../middleware/callMiddleware.js";
 import {
   computeCurrentLocale,
   computePreferredLocale,
   computePreferredLocaleList
-} from "../render/context.js";
-import {} from "../render/index.js";
-const clientAddressSymbol = Symbol.for("astro.clientAddress");
-const clientLocalsSymbol = Symbol.for("astro.locals");
+} from "../../i18n/utils.js";
 function createAPIContext({
   request,
   params,
@@ -19,13 +13,15 @@ function createAPIContext({
   adapterName,
   locales,
   routingStrategy,
-  defaultLocale
+  defaultLocale,
+  route,
+  cookies
 }) {
   let preferredLocale = void 0;
   let preferredLocaleList = void 0;
   let currentLocale = void 0;
   const context = {
-    cookies: new AstroCookies(request),
+    cookies,
     request,
     params,
     site: site ? new URL(site) : void 0,
@@ -64,7 +60,7 @@ function createAPIContext({
         return currentLocale;
       }
       if (locales) {
-        currentLocale = computeCurrentLocale(request, locales, routingStrategy, defaultLocale);
+        currentLocale = computeCurrentLocale(route, locales, routingStrategy, defaultLocale);
       }
       return currentLocale;
     },
@@ -104,29 +100,6 @@ function createAPIContext({
   };
   return context;
 }
-async function callEndpoint(mod, env, ctx, onRequest) {
-  const context = createAPIContext({
-    request: ctx.request,
-    params: ctx.params,
-    props: ctx.props,
-    site: env.site,
-    adapterName: env.adapterName,
-    routingStrategy: ctx.routing,
-    defaultLocale: ctx.defaultLocale,
-    locales: ctx.locales
-  });
-  let response;
-  if (onRequest) {
-    response = await callMiddleware(onRequest, context, async () => {
-      return await renderEndpoint(mod, context, env.ssr, env.logger);
-    });
-  } else {
-    response = await renderEndpoint(mod, context, env.ssr, env.logger);
-  }
-  attachCookiesToResponse(response, context.cookies);
-  return response;
-}
 export {
-  callEndpoint,
   createAPIContext
 };

package/dist/core/errors/errors-data.d.ts

@@ -458,7 +458,7 @@ export declare const InvalidImageService: {
  * - [Images](https://docs.astro.build/en/guides/images/)
  * - [Image component#width-and-height-required](https://docs.astro.build/en/guides/images/#width-and-height-required-for-images-in-public)
  * @description
- * For remote images, `width` and `height` cannot automatically be inferred from the original file. To avoid cumulative layout shift (CLS), either specify these two properties, or set [inferSize`](https://docs.astro.build/en/guides/images/#infersize) to `true` to fetch a remote image's original dimensions.
+ * For remote images, `width` and `height` cannot automatically be inferred from the original file. To avoid cumulative layout shift (CLS), either specify these two properties, or set [`inferSize`](https://docs.astro.build/en/guides/images/#infersize) to `true` to fetch a remote image's original dimensions.
  *
  * If your image is inside your `src` folder, you probably meant to import it instead. See [the Imports guide for more information](https://docs.astro.build/en/guides/imports/#other-assets).
  */
@@ -473,7 +473,7 @@ export declare const MissingImageDimension: {
  * @message
  * Failed to get the dimensions for `IMAGE_URL`.
  * @description
- * Determining the remote image's dimensions failed. This is typically caused by an incorrect URL or attempting to infer the size of an image in the public folder which is not possible. Here is where the probing logic lives in Astro's [sourcecode](https://github.com/withastro/astro/blob/main/packages/astro/src/assets/utils/image-size/).
+ * Determining the remote image's dimensions failed. This is typically caused by an incorrect URL or attempting to infer the size of an image in the public folder which is not possible.
  */
 export declare const FailedToFetchRemoteImageDimensions: {
     name: string;

package/dist/core/messages.js

@@ -36,7 +36,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "4.4.0";
+  const version = "4.4.1";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -261,7 +261,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"4.4.0"}`
+        `v${"4.4.1"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/callMiddleware.d.ts

@@ -33,4 +33,4 @@ import type { APIContext, MiddlewareHandler } from '../../@types/astro.js';
  * @param apiContext The API context
  * @param responseFunction A callback function that should return a promise with the response
  */
-export declare function callMiddleware(onRequest: MiddlewareHandler, apiContext: APIContext, responseFunction: () => Promise<Response>): Promise<Response>;
+export declare function callMiddleware(onRequest: MiddlewareHandler, apiContext: APIContext, responseFunction: () => Promise<Response> | Response): Promise<Response>;

package/dist/core/middleware/callMiddleware.js

@@ -1,4 +1,3 @@
-import { attachCookiesToResponse, responseHasCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 async function callMiddleware(onRequest, apiContext, responseFunction) {
   let nextCalled = false;
@@ -15,7 +14,7 @@ async function callMiddleware(onRequest, apiContext, responseFunction) {
         if (value instanceof Response === false) {
           throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
         }
-        return ensureCookiesAttached(apiContext, value);
+        return value;
       } else {
         if (responseFunctionPromise) {
           return responseFunctionPromise;
@@ -28,16 +27,10 @@ async function callMiddleware(onRequest, apiContext, responseFunction) {
     } else if (value instanceof Response === false) {
       throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
     } else {
-      return ensureCookiesAttached(apiContext, value);
+      return value;
     }
   });
 }
-function ensureCookiesAttached(apiContext, response) {
-  if (apiContext.cookies !== void 0 && !responseHasCookies(response)) {
-    attachCookiesToResponse(response, apiContext.cookies);
-  }
-  return response;
-}
 export {
   callMiddleware
 };

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

@@ -1,4 +1,4 @@
-import type { MiddlewareHandler, Params } from '../../@types/astro.js';
+import type { APIContext, MiddlewareHandler, Params } from '../../@types/astro.js';
 import { sequence } from './sequence.js';
 declare function defineMiddleware(fn: MiddlewareHandler): MiddlewareHandler;
 /**
@@ -21,7 +21,7 @@ export type CreateContext = {
 /**
  * Creates a context to be passed to Astro middleware `onRequest` function.
  */
-declare function createContext({ request, params, userDefinedLocales }: CreateContext): import("../../@types/astro.js").APIContext<Record<string, any>, Record<string, string | undefined>>;
+declare function createContext({ request, params, userDefinedLocales, }: CreateContext): APIContext;
 /**
  * It attempts to serialize `value` and return it as a string.
  *

package/dist/core/middleware/index.js

@@ -1,18 +1,83 @@
-import { createAPIContext } from "../endpoint/index.js";
+import { AstroCookies } from "../cookies/index.js";
 import { sequence } from "./sequence.js";
+import { ASTRO_VERSION } from "../constants.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import {
+  computeCurrentLocale,
+  computePreferredLocale,
+  computePreferredLocaleList
+} from "../../i18n/utils.js";
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+const clientLocalsSymbol = Symbol.for("astro.locals");
 function defineMiddleware(fn) {
   return fn;
 }
-function createContext({ request, params, userDefinedLocales = [] }) {
-  return createAPIContext({
+function createContext({
+  request,
+  params = {},
+  userDefinedLocales = []
+}) {
+  let preferredLocale = void 0;
+  let preferredLocaleList = void 0;
+  let currentLocale = void 0;
+  const url = new URL(request.url);
+  const route = url.pathname;
+  return {
+    cookies: new AstroCookies(request),
     request,
-    params: params ?? {},
-    props: {},
+    params,
     site: void 0,
-    locales: userDefinedLocales,
-    defaultLocale: void 0,
-    routingStrategy: void 0
-  });
+    generator: `Astro v${ASTRO_VERSION}`,
+    props: {},
+    redirect(path, status) {
+      return new Response(null, {
+        status: status || 302,
+        headers: {
+          Location: path
+        }
+      });
+    },
+    get preferredLocale() {
+      return preferredLocale ??= computePreferredLocale(request, userDefinedLocales);
+    },
+    get preferredLocaleList() {
+      return preferredLocaleList ??= computePreferredLocaleList(request, userDefinedLocales);
+    },
+    get currentLocale() {
+      return currentLocale ??= computeCurrentLocale(
+        route,
+        userDefinedLocales,
+        void 0,
+        void 0
+      );
+    },
+    url,
+    get clientAddress() {
+      if (clientAddressSymbol in request) {
+        return Reflect.get(request, clientAddressSymbol);
+      }
+      throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
+    },
+    get locals() {
+      let locals = Reflect.get(request, clientLocalsSymbol);
+      if (locals === void 0) {
+        locals = {};
+        Reflect.set(request, clientLocalsSymbol, locals);
+      }
+      if (typeof locals !== "object") {
+        throw new AstroError(AstroErrorData.LocalsNotAnObject);
+      }
+      return locals;
+    },
+    // We define a custom property, so we can check the value passed to locals
+    set locals(val) {
+      if (typeof val !== "object") {
+        throw new AstroError(AstroErrorData.LocalsNotAnObject);
+      } else {
+        Reflect.set(request, clientLocalsSymbol, val);
+      }
+    }
+  };
 }
 function isLocalsSerializable(value) {
   let type = typeof value;

package/dist/core/module-loader/vite.js

@@ -24,8 +24,8 @@ function createViteLoader(viteServer) {
       events.emit("file-change", args);
     }
   });
-  const _wsSend = viteServer.ws.send;
-  viteServer.ws.send = function(...args) {
+  const _wsSend = viteServer.hot.send;
+  viteServer.hot.send = function(...args) {
     if (isTsconfigUpdated) {
       isTsconfigUpdated = false;
       return;
@@ -63,13 +63,13 @@ function createViteLoader(viteServer) {
       return viteServer.ssrFixStacktrace(err);
     },
     clientReload() {
-      viteServer.ws.send({
+      viteServer.hot.send({
         type: "full-reload",
         path: "*"
       });
     },
     webSocketSend(msg) {
-      return viteServer.ws.send(msg);
+      return viteServer.hot.send(msg);
     },
     isHttps() {
       return !!viteServer.config.server.https;

package/dist/core/preview/index.js

@@ -11,7 +11,9 @@ import { createSettings } from "../config/settings.js";
 import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
 import { ensureProcessNodeEnv } from "../util.js";
+import { apply as applyPolyfills } from "../polyfill.js";
 async function preview(inlineConfig) {
+  applyPolyfills();
   ensureProcessNodeEnv("production");
   const logger = createNodeLogger(inlineConfig);
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "preview");

package/dist/core/preview/static-preview-server.js

@@ -1,6 +1,5 @@
 import { fileURLToPath } from "node:url";
 import { performance } from "perf_hooks";
-import enableDestroy from "server-destroy";
 import { preview } from "vite";
 import * as msg from "../messages.js";
 import { getResolvedHostForHttpServer } from "./util.js";
@@ -30,7 +29,6 @@ async function createStaticPreviewServer(settings, logger) {
     }
     throw err;
   }
-  enableDestroy(previewServer.httpServer);
   logger.info(
     "SKIP_FORMAT",
     msg.serverStart({
@@ -51,11 +49,7 @@ async function createStaticPreviewServer(settings, logger) {
     port: settings.config.server.port,
     closed,
     server: previewServer.httpServer,
-    stop: async () => {
-      await new Promise((resolve, reject) => {
-        previewServer.httpServer.destroy((err) => err ? reject(err) : resolve(void 0));
-      });
-    }
+    stop: previewServer.close.bind(previewServer)
   };
 }
 export {

package/dist/core/redirects/helpers.d.ts

@@ -1,5 +1,3 @@
-import type { Params, RedirectRouteData, RouteData, ValidRedirectStatus } from '../../@types/astro.js';
+import type { RedirectRouteData, RouteData } from '../../@types/astro.js';
 export declare function routeIsRedirect(route: RouteData | undefined): route is RedirectRouteData;
 export declare function routeIsFallback(route: RouteData | undefined): route is RedirectRouteData;
-export declare function redirectRouteGenerate(redirectRoute: RouteData, data: Params): string;
-export declare function redirectRouteStatus(redirectRoute: RouteData, method?: string): ValidRedirectStatus;

package/dist/core/redirects/helpers.js

@@ -4,36 +4,7 @@ function routeIsRedirect(route) {
 function routeIsFallback(route) {
   return route?.type === "fallback";
 }
-function redirectRouteGenerate(redirectRoute, data) {
-  const routeData = redirectRoute.redirectRoute;
-  const route = redirectRoute.redirect;
-  if (typeof routeData !== "undefined") {
-    return routeData?.generate(data) || routeData?.pathname || "/";
-  } else if (typeof route === "string") {
-    let target = route;
-    for (const param of Object.keys(data)) {
-      const paramValue = data[param];
-      target = target.replace(`[${param}]`, paramValue);
-      target = target.replace(`[...${param}]`, paramValue);
-    }
-    return target;
-  } else if (typeof route === "undefined") {
-    return "/";
-  }
-  return route.destination;
-}
-function redirectRouteStatus(redirectRoute, method = "GET") {
-  const routeData = redirectRoute.redirectRoute;
-  if (routeData && typeof redirectRoute.redirect === "object") {
-    return redirectRoute.redirect.status;
-  } else if (method !== "GET") {
-    return 308;
-  }
-  return 301;
-}
 export {
-  redirectRouteGenerate,
-  redirectRouteStatus,
   routeIsFallback,
   routeIsRedirect
 };

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

@@ -1,3 +1,4 @@
 export { RedirectComponentInstance, RedirectSinglePageBuiltModule } from './component.js';
-export { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from './helpers.js';
+export { routeIsRedirect } from './helpers.js';
 export { getRedirectLocationOrThrow } from './validate.js';
+export { renderRedirect } from './render.js';

package/dist/core/redirects/index.js

@@ -1,11 +1,11 @@
 import { RedirectComponentInstance, RedirectSinglePageBuiltModule } from "./component.js";
-import { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from "./helpers.js";
+import { routeIsRedirect } from "./helpers.js";
 import { getRedirectLocationOrThrow } from "./validate.js";
+import { renderRedirect } from "./render.js";
 export {
   RedirectComponentInstance,
   RedirectSinglePageBuiltModule,
   getRedirectLocationOrThrow,
-  redirectRouteGenerate,
-  redirectRouteStatus,
+  renderRedirect,
   routeIsRedirect
 };

package/dist/core/redirects/render.d.ts

@@ -0,0 +1,2 @@
+import type { RenderContext } from '../render-context.js';
+export declare function renderRedirect(renderContext: RenderContext): Promise<Response>;

package/dist/core/redirects/render.js

@@ -0,0 +1,33 @@
+async function renderRedirect(renderContext) {
+  const {
+    request: { method },
+    routeData
+  } = renderContext;
+  const { redirect, redirectRoute } = routeData;
+  const status = redirectRoute && typeof redirect === "object" ? redirect.status : method === "GET" ? 301 : 308;
+  const headers = { location: redirectRouteGenerate(renderContext) };
+  return new Response(null, { status, headers });
+}
+function redirectRouteGenerate(renderContext) {
+  const {
+    params,
+    routeData: { redirect, redirectRoute }
+  } = renderContext;
+  if (typeof redirectRoute !== "undefined") {
+    return redirectRoute?.generate(params) || redirectRoute?.pathname || "/";
+  } else if (typeof redirect === "string") {
+    let target = redirect;
+    for (const param of Object.keys(params)) {
+      const paramValue = params[param];
+      target = target.replace(`[${param}]`, paramValue);
+      target = target.replace(`[...${param}]`, paramValue);
+    }
+    return target;
+  } else if (typeof redirect === "undefined") {
+    return "/";
+  }
+  return redirect.destination;
+}
+export {
+  renderRedirect
+};

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

@@ -1,14 +1,12 @@
-import type { AstroMiddlewareInstance, ComponentInstance, RouteData } from '../../@types/astro.js';
-import type { Environment } from './environment.js';
-export { computePreferredLocale, createRenderContext } from './context.js';
-export type { RenderContext } from './context.js';
-export { createEnvironment } from './environment.js';
-export { getParamsAndProps } from './params-and-props.js';
+import type { ComponentInstance, RouteData } from '../../@types/astro.js';
+import type { Pipeline } from '../base-pipeline.js';
+export { Pipeline } from '../base-pipeline.js';
+export { getParams, getProps } from './params-and-props.js';
 export { loadRenderer } from './renderer.js';
-export type { Environment };
+export { createResult } from './result.js';
 export interface SSROptions {
-    /** The environment instance */
-    env: Environment;
+    /** The pipeline instance */
+    pipeline: Pipeline;
     /** location of file on disk */
     filePath: URL;
     /** the web request (needed for dynamic routes) */
@@ -19,8 +17,4 @@ export interface SSROptions {
     request: Request;
     /** optional, in case we need to render something outside a dev server */
     route: RouteData;
-    /**
-     * Optional middlewares
-     */
-    middleware?: AstroMiddlewareInstance;
 }

package/dist/core/render/index.js

@@ -1,11 +1,11 @@
-import { computePreferredLocale, createRenderContext } from "./context.js";
-import { createEnvironment } from "./environment.js";
-import { getParamsAndProps } from "./params-and-props.js";
+import { Pipeline } from "../base-pipeline.js";
+import { getParams, getProps } from "./params-and-props.js";
 import { loadRenderer } from "./renderer.js";
+import { createResult } from "./result.js";
 export {
-  computePreferredLocale,
-  createEnvironment,
-  createRenderContext,
-  getParamsAndProps,
+  Pipeline,
+  createResult,
+  getParams,
+  getProps,
   loadRenderer
 };

package/dist/core/render/params-and-props.d.ts

@@ -3,11 +3,16 @@ import type { Logger } from '../logger/core.js';
 import type { RouteCache } from './route-cache.js';
 interface GetParamsAndPropsOptions {
     mod: ComponentInstance | undefined;
-    route?: RouteData | undefined;
+    routeData?: RouteData | undefined;
     routeCache: RouteCache;
     pathname: string;
     logger: Logger;
-    ssr: boolean;
+    serverLike: boolean;
 }
-export declare function getParamsAndProps(opts: GetParamsAndPropsOptions): Promise<[Params, Props]>;
+export declare function getProps(opts: GetParamsAndPropsOptions): Promise<Props>;
+/**
+ * When given a route with the pattern `/[x]/[y]/[z]/svelte`, and a pathname `/a/b/c/svelte`,
+ * returns the params object: { x: "a", y: "b", z: "c" }.
+ */
+export declare function getParams(route: RouteData, pathname: string): Params;
 export {};

package/dist/core/render/params-and-props.js

@@ -1,17 +1,16 @@
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { routeIsFallback } from "../redirects/helpers.js";
 import { routeIsRedirect } from "../redirects/index.js";
-import { getParams } from "../routing/params.js";
 import { callGetStaticPaths, findPathItemByKey } from "./route-cache.js";
-async function getParamsAndProps(opts) {
-  const { logger, mod, route, routeCache, pathname, ssr } = opts;
+async function getProps(opts) {
+  const { logger, mod, routeData: route, routeCache, pathname, serverLike } = opts;
   if (!route || route.pathname) {
-    return [{}, {}];
+    return {};
   }
-  const params = getRouteParams(route, pathname) ?? {};
   if (routeIsRedirect(route) || routeIsFallback(route)) {
-    return [params, {}];
+    return {};
   }
+  const params = getParams(route, pathname);
   if (mod) {
     validatePrerenderEndpointCollision(route, mod, params);
   }
@@ -20,10 +19,10 @@ async function getParamsAndProps(opts) {
     route,
     routeCache,
     logger,
-    ssr
+    ssr: serverLike
   });
   const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
-  if (!matchedStaticPath && (ssr ? route.prerender : true)) {
+  if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
     throw new AstroError({
       ...AstroErrorData.NoMatchingStaticPathFound,
       message: AstroErrorData.NoMatchingStaticPathFound.message(pathname),
@@ -31,15 +30,23 @@ async function getParamsAndProps(opts) {
     });
   }
   const props = matchedStaticPath?.props ? { ...matchedStaticPath.props } : {};
-  return [params, props];
+  return props;
 }
-function getRouteParams(route, pathname) {
-  if (route.params.length) {
-    const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
-    if (paramsMatch) {
-      return getParams(route.params)(paramsMatch);
+function getParams(route, pathname) {
+  if (!route.params.length)
+    return {};
+  const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
+  if (!paramsMatch)
+    return {};
+  const params = {};
+  route.params.forEach((key, i) => {
+    if (key.startsWith("...")) {
+      params[key.slice(3)] = paramsMatch[i + 1] ? paramsMatch[i + 1] : void 0;
+    } else {
+      params[key] = paramsMatch[i + 1];
     }
-  }
+  });
+  return params;
 }
 function validatePrerenderEndpointCollision(route, mod, params) {
   if (route.type === "endpoint" && mod.getStaticPaths) {
@@ -59,5 +66,6 @@ function validatePrerenderEndpointCollision(route, mod, params) {
   }
 }
 export {
-  getParamsAndProps
+  getParams,
+  getProps
 };

package/dist/core/render/result.d.ts

@@ -23,16 +23,17 @@ export interface CreateResultArgs {
      * Used for `Astro.site`
      */
     site: string | undefined;
-    links?: Set<SSRElement>;
-    scripts?: Set<SSRElement>;
-    styles?: Set<SSRElement>;
-    componentMetadata?: SSRResult['componentMetadata'];
+    links: Set<SSRElement>;
+    scripts: Set<SSRElement>;
+    styles: Set<SSRElement>;
+    componentMetadata: SSRResult['componentMetadata'];
     request: Request;
     status: number;
     locals: App.Locals;
-    cookies?: AstroCookies;
+    cookies: AstroCookies;
     locales: Locales | undefined;
     defaultLocale: string | undefined;
+    route: string;
     routingStrategy: RoutingStrategies | undefined;
 }
 export declare function createResult(args: CreateResultArgs): SSRResult;

package/dist/core/render/result.js

@@ -7,9 +7,8 @@ import {
   computeCurrentLocale,
   computePreferredLocale,
   computePreferredLocaleList
-} from "./context.js";
-const clientAddressSymbol = Symbol.for("astro.clientAddress");
-const responseSentSymbol = Symbol.for("astro.responseSent");
+} from "../../i18n/utils.js";
+import { clientAddressSymbol, responseSentSymbol } from "../constants.js";
 function getFunctionExpression(slot) {
   if (!slot)
     return;
@@ -160,7 +159,7 @@ function createResult(args) {
           }
           if (args.locales) {
             currentLocale = computeCurrentLocale(
-              request,
+              url.pathname,
               args.locales,
               args.routingStrategy,
               args.defaultLocale

package/dist/core/render-context.d.ts

@@ -0,0 +1,32 @@
+import type { APIContext, ComponentInstance, MiddlewareHandler, RouteData } from '../@types/astro.js';
+import { AstroCookies } from './cookies/index.js';
+import { type Pipeline } from './render/index.js';
+export declare class RenderContext {
+    #private;
+    readonly pipeline: Pipeline;
+    locals: App.Locals;
+    readonly middleware: MiddlewareHandler;
+    readonly pathname: string;
+    readonly request: Request;
+    readonly routeData: RouteData;
+    status: number;
+    readonly cookies: AstroCookies;
+    readonly params: import("../@types/astro.js").Params;
+    private constructor();
+    static create({ locals, middleware, pathname, pipeline, request, routeData, status, }: Pick<RenderContext, 'pathname' | 'pipeline' | 'request' | 'routeData'> & Partial<Pick<RenderContext, 'locals' | 'middleware' | 'status'>>): RenderContext;
+    /**
+     * The main function of the RenderContext.
+     *
+     * Use this function to render any route known to Astro.
+     * It attempts to render a route. A route can be a:
+     *
+     * - page
+     * - redirect
+     * - endpoint
+     * - fallback
+     */
+    render(componentInstance: ComponentInstance | undefined): Promise<Response>;
+    createAPIContext(props: APIContext['props']): APIContext;
+    createResult(mod: ComponentInstance): Promise<import("../@types/astro.js").SSRResult>;
+    get i18nData(): Pick<APIContext<Record<string, any>, Record<string, string | undefined>>, "currentLocale" | "preferredLocale" | "preferredLocaleList">;
+}