cloudcommerce 2.6.2 → 2.6.4

package/packages/storefront/dist/server/entry.mjs

@@ -1,244 +1,26 @@
 import { renderers } from './renderers.mjs';
-import { l as levels, g as getEventPrefix, L as Logger, A as AstroIntegrationLogger, manifest } from './manifest_9FASPYUE.mjs';
-import fs from 'node:fs';
-import { appendForwardSlash as appendForwardSlash$1, joinPaths, trimSlashes, slash, prependForwardSlash as prependForwardSlash$1, removeTrailingForwardSlash, collapseDuplicateSlashes } from '@astrojs/internal-helpers/path';
-import { R as ROUTE_DATA_SYMBOL, A as AstroError, o as ResponseSentError, p as MiddlewareNoDataOrNextCalled, q as MiddlewareNotAResponse, G as GetStaticPathsRequired, t as InvalidGetStaticPathsReturn, v as InvalidGetStaticPathsEntry, w as GetStaticPathsExpectedParams, x as GetStaticPathsInvalidRouteParam, P as PageNumberParamNotFound, N as NoMatchingStaticPathFound, y as PrerenderDynamicEndpointPathCollide, z as LocalsNotAnObject, B as ASTRO_VERSION, C as ClientAddressNotAvailable, S as StaticClientAddressNotAvailable, D as renderEndpoint, H as ReservedSlotName, k as renderSlotToString, J as renderJSX, K as chunkToString, O as CantRenderPage, Q as renderPage$1, T as REROUTE_DIRECTIVE_HEADER } from './chunks/astro_u-oSb215.mjs';
+import { l as levels, g as getEventPrefix, L as Logger, A as AstroIntegrationLogger, manifest } from './manifest_KFjAaJaC.mjs';
 import { serialize, parse } from 'cookie';
+import { A as AstroError, R as ResponseSentError, G as GetStaticPathsRequired, p as InvalidGetStaticPathsReturn, q as InvalidGetStaticPathsEntry, t as GetStaticPathsExpectedParams, v as GetStaticPathsInvalidRouteParam, P as PageNumberParamNotFound, w as ROUTE_TYPE_HEADER, x as MiddlewareNoDataOrNextCalled, y as MiddlewareNotAResponse, N as NoMatchingStaticPathFound, z as PrerenderDynamicEndpointPathCollide, B as ReservedSlotName, k as renderSlotToString, C as renderJSX, D as chunkToString, H as clientAddressSymbol$1, J as ClientAddressNotAvailable, S as StaticClientAddressNotAvailable, K as responseSentSymbol$1, O as LocalsNotAnObject, Q as clientLocalsSymbol, T as ASTRO_VERSION, V as renderEndpoint, W as renderPage, X as REROUTABLE_STATUS_CODES, Y as REROUTE_DIRECTIVE_HEADER } from './chunks/astro_ISB6VLqs.mjs';
+import { joinPaths, slash, prependForwardSlash as prependForwardSlash$1, trimSlashes, appendForwardSlash as appendForwardSlash$1, removeTrailingForwardSlash, collapseDuplicateSlashes } from '@astrojs/internal-helpers/path';
 import 'kleur/colors';
 import 'clsx';
-import 'cssesc';
-import buffer from 'node:buffer';
-import crypto from 'node:crypto';
 import http from 'node:http';
 import https$1 from 'https';
+import fs from 'node:fs';
 import enableDestroy from 'server-destroy';
 import path from 'node:path';
 import url from 'node:url';
 import send from 'send';
 import os from 'node:os';
 import https from 'node:https';
+import buffer from 'node:buffer';
+import crypto from 'node:crypto';
 import { onRequest } from './_noop-middleware.mjs';
 
-function shouldAppendForwardSlash(trailingSlash, buildFormat) {
-  switch (trailingSlash) {
-    case "always":
-      return true;
-    case "never":
-      return false;
-    case "ignore": {
-      switch (buildFormat) {
-        case "directory":
-          return true;
-        case "preserve":
-        case "file":
-          return false;
-      }
-    }
-  }
-}
-
-function getPathByLocale(locale, locales) {
-  for (const loopLocale of locales) {
-    if (typeof loopLocale === "string") {
-      if (loopLocale === locale) {
-        return loopLocale;
-      }
-    } else {
-      for (const code of loopLocale.codes) {
-        if (code === locale) {
-          return loopLocale.path;
-        }
-      }
-    }
-  }
-  throw new Unreachable();
-}
-function normalizeTheLocale(locale) {
-  return locale.replaceAll("_", "-").toLowerCase();
-}
-function toCodes(locales) {
-  const codes = [];
-  for (const locale of locales) {
-    if (typeof locale === "string") {
-      codes.push(locale);
-    } else {
-      for (const code of locale.codes) {
-        codes.push(code);
-      }
-    }
-  }
-  return codes;
-}
-class Unreachable extends Error {
-  constructor() {
-    super(
-      "Astro encountered an unexpected line of code.\nIn most cases, this is not your fault, but a bug in astro code.\nIf there isn't one already, please create an issue.\nhttps://astro.build/issues"
-    );
-  }
-}
-
-const routeDataSymbol$1 = Symbol.for(ROUTE_DATA_SYMBOL);
-function pathnameHasLocale(pathname, locales) {
-  const segments = pathname.split("/");
-  for (const segment of segments) {
-    for (const locale of locales) {
-      if (typeof locale === "string") {
-        if (normalizeTheLocale(segment) === normalizeTheLocale(locale)) {
-          return true;
-        }
-      } else if (segment === locale.path) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function createI18nMiddleware(i18n, base, trailingSlash, buildFormat) {
-  if (!i18n)
-    return (_, next) => next();
-  const prefixAlways = (url, response, context) => {
-    if (url.pathname === base + "/" || url.pathname === base) {
-      if (shouldAppendForwardSlash(trailingSlash, buildFormat)) {
-        return context.redirect(`${appendForwardSlash$1(joinPaths(base, i18n.defaultLocale))}`);
-      } else {
-        return context.redirect(`${joinPaths(base, i18n.defaultLocale)}`);
-      }
-    } else if (!pathnameHasLocale(url.pathname, i18n.locales)) {
-      return new Response(null, {
-        status: 404,
-        headers: response.headers
-      });
-    }
-    return void 0;
-  };
-  const prefixOtherLocales = (url, response) => {
-    const pathnameContainsDefaultLocale = url.pathname.includes(`/${i18n.defaultLocale}`);
-    if (pathnameContainsDefaultLocale) {
-      const newLocation = url.pathname.replace(`/${i18n.defaultLocale}`, "");
-      response.headers.set("Location", newLocation);
-      return new Response(null, {
-        status: 404,
-        headers: response.headers
-      });
-    }
-    return void 0;
-  };
-  const prefixAlwaysNoRedirect = (url, response) => {
-    const isRoot = url.pathname === base + "/" || url.pathname === base;
-    if (!(isRoot || pathnameHasLocale(url.pathname, i18n.locales))) {
-      return new Response(null, {
-        status: 404,
-        headers: response.headers
-      });
-    }
-    return void 0;
-  };
-  return async (context, next) => {
-    const routeData = Reflect.get(context.request, routeDataSymbol$1);
-    if (routeData?.type !== "page" && routeData?.type !== "fallback") {
-      return await next();
-    }
-    const currentLocale = context.currentLocale;
-    const url = context.url;
-    const { locales, defaultLocale, fallback, routing } = i18n;
-    const response = await next();
-    if (response instanceof Response) {
-      switch (i18n.routing) {
-        case "domains-prefix-other-locales": {
-          if (localeHasntDomain(i18n, currentLocale)) {
-            const result = prefixOtherLocales(url, response);
-            if (result) {
-              return result;
-            }
-          }
-          break;
-        }
-        case "pathname-prefix-other-locales": {
-          const result = prefixOtherLocales(url, response);
-          if (result) {
-            return result;
-          }
-          break;
-        }
-        case "domains-prefix-other-no-redirect": {
-          if (localeHasntDomain(i18n, currentLocale)) {
-            const result = prefixAlwaysNoRedirect(url, response);
-            if (result) {
-              return result;
-            }
-          }
-          break;
-        }
-        case "pathname-prefix-always-no-redirect": {
-          const result = prefixAlwaysNoRedirect(url, response);
-          if (result) {
-            return result;
-          }
-          break;
-        }
-        case "pathname-prefix-always": {
-          const result = prefixAlways(url, response, context);
-          if (result) {
-            return result;
-          }
-          break;
-        }
-        case "domains-prefix-always": {
-          if (localeHasntDomain(i18n, currentLocale)) {
-            const result = prefixAlways(url, response, context);
-            if (result) {
-              return result;
-            }
-          }
-          break;
-        }
-      }
-      if (response.status >= 300 && fallback) {
-        const fallbackKeys = i18n.fallback ? Object.keys(i18n.fallback) : [];
-        const segments = url.pathname.split("/");
-        const urlLocale = segments.find((segment) => {
-          for (const locale of locales) {
-            if (typeof locale === "string") {
-              if (locale === segment) {
-                return true;
-              }
-            } else if (locale.path === segment) {
-              return true;
-            }
-          }
-          return false;
-        });
-        if (urlLocale && fallbackKeys.includes(urlLocale)) {
-          const fallbackLocale = fallback[urlLocale];
-          const pathFallbackLocale = getPathByLocale(fallbackLocale, locales);
-          let newPathname;
-          if (pathFallbackLocale === defaultLocale && routing === "pathname-prefix-other-locales") {
-            newPathname = url.pathname.replace(`/${urlLocale}`, ``);
-          } else {
-            newPathname = url.pathname.replace(`/${urlLocale}`, `/${pathFallbackLocale}`);
-          }
-          return context.redirect(newPathname);
-        }
-      }
-    }
-    return response;
-  };
-}
-const i18nPipelineHook = (ctx) => {
-  Reflect.set(ctx.request, routeDataSymbol$1, ctx.route);
-};
-function localeHasntDomain(i18n, currentLocale) {
-  for (const domainLocale of Object.values(i18n.domainLookupTable)) {
-    if (domainLocale === currentLocale) {
-      return false;
-    }
-  }
-  return true;
-}
-
 const DELETED_EXPIRATION = /* @__PURE__ */ new Date(0);
 const DELETED_VALUE = "deleted";
-const responseSentSymbol$2 = Symbol.for("astro.responseSent");
+const responseSentSymbol = Symbol.for("astro.responseSent");
 class AstroCookie {
   constructor(value) {
     this.value = value;
@@ -366,7 +148,7 @@ class AstroCookies {
       serialize(key, serializedValue, serializeOptions),
       true
     ]);
-    if (this.#request[responseSentSymbol$2]) {
+    if (this.#request[responseSentSymbol]) {
       throw new AstroError({
         ...ResponseSentError
       });
@@ -421,9 +203,6 @@ const astroCookiesSymbol = Symbol.for("astro.cookies");
 function attachCookiesToResponse(response, cookies) {
   Reflect.set(response, astroCookiesSymbol, cookies);
 }
-function responseHasCookies(response) {
-  return Reflect.has(response, astroCookiesSymbol);
-}
 function getFromResponse(response) {
   let cookies = Reflect.get(response, astroCookiesSymbol);
   if (cookies != null) {
@@ -458,44 +237,18 @@ const consoleLogDestination = {
   }
 };
 
-async function callMiddleware(onRequest, apiContext, responseFunction) {
-  let nextCalled = false;
-  let responseFunctionPromise = void 0;
-  const next = async () => {
-    nextCalled = true;
-    responseFunctionPromise = responseFunction();
-    return responseFunctionPromise;
-  };
-  let middlewarePromise = onRequest(apiContext, next);
-  return await Promise.resolve(middlewarePromise).then(async (value) => {
-    if (nextCalled) {
-      if (typeof value !== "undefined") {
-        if (value instanceof Response === false) {
-          throw new AstroError(MiddlewareNotAResponse);
-        }
-        return ensureCookiesAttached(apiContext, value);
-      } else {
-        if (responseFunctionPromise) {
-          return responseFunctionPromise;
-        } else {
-          throw new AstroError(MiddlewareNotAResponse);
-        }
-      }
-    } else if (typeof value === "undefined") {
-      throw new AstroError(MiddlewareNoDataOrNextCalled);
-    } else if (value instanceof Response === false) {
-      throw new AstroError(MiddlewareNotAResponse);
-    } else {
-      return ensureCookiesAttached(apiContext, value);
-    }
-  });
-}
-function ensureCookiesAttached(apiContext, response) {
-  if (apiContext.cookies !== void 0 && !responseHasCookies(response)) {
-    attachCookiesToResponse(response, apiContext.cookies);
+const RedirectComponentInstance = {
+  default() {
+    return new Response(null, {
+      status: 301
+    });
   }
-  return response;
-}
+};
+const RedirectSinglePageBuiltModule = {
+  page: () => Promise.resolve(RedirectComponentInstance),
+  onRequest: (_, next) => next(),
+  renderers: []
+};
 
 function routeIsRedirect(route) {
   return route?.type === "redirect";
@@ -503,68 +256,116 @@ 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];
+
+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 route === "undefined") {
+  } else if (typeof redirect === "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;
+  return redirect.destination;
 }
 
-const RedirectComponentInstance = {
-  default() {
-    return new Response(null, {
-      status: 301
-    });
-  }
-};
-const RedirectSinglePageBuiltModule = {
-  page: () => Promise.resolve(RedirectComponentInstance),
-  onRequest: (_, next) => next(),
-  renderers: []
-};
-
-const VALID_PARAM_TYPES = ["string", "number", "undefined"];
-function validateGetStaticPathsParameter([key, value], route) {
-  if (!VALID_PARAM_TYPES.includes(typeof value)) {
-    throw new AstroError({
-      ...GetStaticPathsInvalidRouteParam,
-      message: GetStaticPathsInvalidRouteParam.message(key, value, typeof value),
-      location: {
-        file: route
-      }
-    });
+function createAssetLink(href, base, assetsPrefix) {
+  if (assetsPrefix) {
+    return joinPaths(assetsPrefix, slash(href));
+  } else if (base) {
+    return prependForwardSlash$1(joinPaths(base, slash(href)));
+  } else {
+    return href;
   }
 }
-function validateDynamicRouteModule(mod, {
-  ssr,
-  route
-}) {
-  if ((!ssr || route.prerender) && !mod.getStaticPaths) {
-    throw new AstroError({
-      ...GetStaticPathsRequired,
-      location: { file: route.component }
-    });
+function createStylesheetElement(stylesheet, base, assetsPrefix) {
+  if (stylesheet.type === "inline") {
+    return {
+      props: {},
+      children: stylesheet.content
+    };
+  } else {
+    return {
+      props: {
+        rel: "stylesheet",
+        href: createAssetLink(stylesheet.src, base, assetsPrefix)
+      },
+      children: ""
+    };
+  }
+}
+function createStylesheetElementSet(stylesheets, base, assetsPrefix) {
+  return new Set(stylesheets.map((s) => createStylesheetElement(s, base, assetsPrefix)));
+}
+function createModuleScriptElement(script, base, assetsPrefix) {
+  if (script.type === "external") {
+    return createModuleScriptElementWithSrc(script.value, base, assetsPrefix);
+  } else {
+    return {
+      props: {
+        type: "module"
+      },
+      children: script.value
+    };
+  }
+}
+function createModuleScriptElementWithSrc(src, base, assetsPrefix) {
+  return {
+    props: {
+      type: "module",
+      src: createAssetLink(src, base, assetsPrefix)
+    },
+    children: ""
+  };
+}
+
+function matchRoute(pathname, manifest) {
+  const decodedPathname = decodeURI(pathname);
+  return manifest.routes.find((route) => {
+    return route.pattern.test(decodedPathname) || route.fallbackRoutes.some((fallbackRoute) => fallbackRoute.pattern.test(decodedPathname));
+  });
+}
+
+const VALID_PARAM_TYPES = ["string", "number", "undefined"];
+function validateGetStaticPathsParameter([key, value], route) {
+  if (!VALID_PARAM_TYPES.includes(typeof value)) {
+    throw new AstroError({
+      ...GetStaticPathsInvalidRouteParam,
+      message: GetStaticPathsInvalidRouteParam.message(key, value, typeof value),
+      location: {
+        file: route
+      }
+    });
+  }
+}
+function validateDynamicRouteModule(mod, {
+  ssr,
+  route
+}) {
+  if ((!ssr || route.prerender) && !mod.getStaticPaths) {
+    throw new AstroError({
+      ...GetStaticPathsRequired,
+      location: { file: route.component }
+    });
   }
 }
 function validateGetStaticPathsResult(result, logger, route) {
@@ -613,20 +414,6 @@ function validateGetStaticPathsResult(result, logger, route) {
   });
 }
 
-function getParams(array) {
-  const fn = (match) => {
-    const params = {};
-    array.forEach((key, i) => {
-      if (key.startsWith("...")) {
-        params[key.slice(3)] = match[i + 1] ? match[i + 1] : void 0;
-      } else {
-        params[key] = match[i + 1];
-      }
-    });
-    return params;
-  };
-  return fn;
-}
 function stringifyParams(params, route) {
   const validatedParams = Object.entries(params).reduce((acc, next) => {
     validateGetStaticPathsParameter(next, route.component);
@@ -771,99 +558,334 @@ function findPathItemByKey(staticPaths, params, route, logger) {
   logger.debug("router", `findPathItemByKey() - Unexpected cache miss looking for ${paramsKey}`);
 }
 
-async function getParamsAndProps(opts) {
-  const { logger, mod, route, routeCache, pathname, ssr } = opts;
-  if (!route || route.pathname) {
-    return [{}, {}];
-  }
-  const params = getRouteParams(route, pathname) ?? {};
-  if (routeIsRedirect(route) || routeIsFallback(route)) {
-    return [params, {}];
+function shouldAppendForwardSlash(trailingSlash, buildFormat) {
+  switch (trailingSlash) {
+    case "always":
+      return true;
+    case "never":
+      return false;
+    case "ignore": {
+      switch (buildFormat) {
+        case "directory":
+          return true;
+        case "preserve":
+        case "file":
+          return false;
+      }
+    }
   }
-  if (mod) {
-    validatePrerenderEndpointCollision(route, mod, params);
+}
+
+function getPathByLocale(locale, locales) {
+  for (const loopLocale of locales) {
+    if (typeof loopLocale === "string") {
+      if (loopLocale === locale) {
+        return loopLocale;
+      }
+    } else {
+      for (const code of loopLocale.codes) {
+        if (code === locale) {
+          return loopLocale.path;
+        }
+      }
+    }
   }
-  const staticPaths = await callGetStaticPaths({
-    mod,
-    route,
-    routeCache,
-    logger,
-    ssr
+  throw new Unreachable();
+}
+function normalizeTheLocale(locale) {
+  return locale.replaceAll("_", "-").toLowerCase();
+}
+function toCodes(locales) {
+  return locales.map((loopLocale) => {
+    if (typeof loopLocale === "string") {
+      return loopLocale;
+    } else {
+      return loopLocale.codes[0];
+    }
   });
-  const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
-  if (!matchedStaticPath && (ssr ? route.prerender : true)) {
-    throw new AstroError({
-      ...NoMatchingStaticPathFound,
-      message: NoMatchingStaticPathFound.message(pathname),
-      hint: NoMatchingStaticPathFound.hint([route.component])
-    });
+}
+class Unreachable extends Error {
+  constructor() {
+    super(
+      "Astro encountered an unexpected line of code.\nIn most cases, this is not your fault, but a bug in astro code.\nIf there isn't one already, please create an issue.\nhttps://astro.build/issues"
+    );
   }
-  const props = matchedStaticPath?.props ? { ...matchedStaticPath.props } : {};
-  return [params, props];
 }
-function getRouteParams(route, pathname) {
-  if (route.params.length) {
-    const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
-    if (paramsMatch) {
-      return getParams(route.params)(paramsMatch);
+
+function pathnameHasLocale(pathname, locales) {
+  const segments = pathname.split("/");
+  for (const segment of segments) {
+    for (const locale of locales) {
+      if (typeof locale === "string") {
+        if (normalizeTheLocale(segment) === normalizeTheLocale(locale)) {
+          return true;
+        }
+      } else if (segment === locale.path) {
+        return true;
+      }
     }
   }
+  return false;
 }
-function validatePrerenderEndpointCollision(route, mod, params) {
-  if (route.type === "endpoint" && mod.getStaticPaths) {
-    const lastSegment = route.segments[route.segments.length - 1];
-    const paramValues = Object.values(params);
-    const lastParam = paramValues[paramValues.length - 1];
-    if (lastSegment.length === 1 && lastSegment[0].dynamic && lastParam === void 0) {
-      throw new AstroError({
-        ...PrerenderDynamicEndpointPathCollide,
-        message: PrerenderDynamicEndpointPathCollide.message(route.route),
-        hint: PrerenderDynamicEndpointPathCollide.hint(route.component),
-        location: {
-          file: route.component
+function createI18nMiddleware(i18n, base, trailingSlash, buildFormat) {
+  if (!i18n)
+    return (_, next) => next();
+  const prefixAlways = (url, response, context) => {
+    if (url.pathname === base + "/" || url.pathname === base) {
+      if (shouldAppendForwardSlash(trailingSlash, buildFormat)) {
+        return context.redirect(`${appendForwardSlash$1(joinPaths(base, i18n.defaultLocale))}`);
+      } else {
+        return context.redirect(`${joinPaths(base, i18n.defaultLocale)}`);
+      }
+    } else if (!pathnameHasLocale(url.pathname, i18n.locales)) {
+      return new Response(null, {
+        status: 404,
+        headers: response.headers
+      });
+    }
+    return void 0;
+  };
+  const prefixOtherLocales = (url, response) => {
+    let pathnameContainsDefaultLocale = false;
+    for (const segment of url.pathname.split("/")) {
+      if (normalizeTheLocale(segment) === normalizeTheLocale(i18n.defaultLocale)) {
+        pathnameContainsDefaultLocale = true;
+        break;
+      }
+    }
+    if (pathnameContainsDefaultLocale) {
+      const newLocation = url.pathname.replace(`/${i18n.defaultLocale}`, "");
+      response.headers.set("Location", newLocation);
+      return new Response(null, {
+        status: 404,
+        headers: response.headers
+      });
+    }
+    return void 0;
+  };
+  const prefixAlwaysNoRedirect = (url, response) => {
+    const isRoot = url.pathname === base + "/" || url.pathname === base;
+    if (!(isRoot || pathnameHasLocale(url.pathname, i18n.locales))) {
+      return new Response(null, {
+        status: 404,
+        headers: response.headers
+      });
+    }
+    return void 0;
+  };
+  return async (context, next) => {
+    const response = await next();
+    const type = response.headers.get(ROUTE_TYPE_HEADER);
+    if (type !== "page" && type !== "fallback") {
+      return response;
+    }
+    const { url, currentLocale } = context;
+    const { locales, defaultLocale, fallback, strategy } = i18n;
+    switch (i18n.strategy) {
+      case "domains-prefix-other-locales": {
+        if (localeHasntDomain(i18n, currentLocale)) {
+          const result = prefixOtherLocales(url, response);
+          if (result) {
+            return result;
+          }
+        }
+        break;
+      }
+      case "pathname-prefix-other-locales": {
+        const result = prefixOtherLocales(url, response);
+        if (result) {
+          return result;
+        }
+        break;
+      }
+      case "domains-prefix-always-no-redirect": {
+        if (localeHasntDomain(i18n, currentLocale)) {
+          const result = prefixAlwaysNoRedirect(url, response);
+          if (result) {
+            return result;
+          }
+        }
+        break;
+      }
+      case "pathname-prefix-always-no-redirect": {
+        const result = prefixAlwaysNoRedirect(url, response);
+        if (result) {
+          return result;
+        }
+        break;
+      }
+      case "pathname-prefix-always": {
+        const result = prefixAlways(url, response, context);
+        if (result) {
+          return result;
+        }
+        break;
+      }
+      case "domains-prefix-always": {
+        if (localeHasntDomain(i18n, currentLocale)) {
+          const result = prefixAlways(url, response, context);
+          if (result) {
+            return result;
+          }
         }
+        break;
+      }
+    }
+    if (response.status >= 300 && fallback) {
+      const fallbackKeys = i18n.fallback ? Object.keys(i18n.fallback) : [];
+      const segments = url.pathname.split("/");
+      const urlLocale = segments.find((segment) => {
+        for (const locale of locales) {
+          if (typeof locale === "string") {
+            if (locale === segment) {
+              return true;
+            }
+          } else if (locale.path === segment) {
+            return true;
+          }
+        }
+        return false;
       });
+      if (urlLocale && fallbackKeys.includes(urlLocale)) {
+        const fallbackLocale = fallback[urlLocale];
+        const pathFallbackLocale = getPathByLocale(fallbackLocale, locales);
+        let newPathname;
+        if (pathFallbackLocale === defaultLocale && strategy === "pathname-prefix-other-locales") {
+          newPathname = url.pathname.replace(`/${urlLocale}`, ``);
+        } else {
+          newPathname = url.pathname.replace(`/${urlLocale}`, `/${pathFallbackLocale}`);
+        }
+        return context.redirect(newPathname);
+      }
+    }
+    return response;
+  };
+}
+function localeHasntDomain(i18n, currentLocale) {
+  for (const domainLocale of Object.values(i18n.domainLookupTable)) {
+    if (domainLocale === currentLocale) {
+      return false;
     }
   }
+  return true;
 }
 
-const clientLocalsSymbol$1 = Symbol.for("astro.locals");
-const routeDataSymbol = Symbol.for(ROUTE_DATA_SYMBOL);
-async function createRenderContext(options) {
-  const request = options.request;
-  const pathname = options.pathname ?? new URL(request.url).pathname;
-  const [params, props] = await getParamsAndProps({
-    mod: options.mod,
-    route: options.route,
-    routeCache: options.env.routeCache,
-    pathname,
-    logger: options.env.logger,
-    ssr: options.env.ssr
-  });
-  const context = {
-    ...options,
-    pathname,
-    params,
-    props,
-    locales: options.locales,
-    routing: options.routing,
-    defaultLocale: options.defaultLocale
+class Pipeline {
+  constructor(logger, manifest, mode, renderers, resolve, serverLike, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, mode), site = manifest.site) {
+    this.logger = logger;
+    this.manifest = manifest;
+    this.mode = mode;
+    this.renderers = renderers;
+    this.resolve = resolve;
+    this.serverLike = serverLike;
+    this.streaming = streaming;
+    this.adapterName = adapterName;
+    this.clientDirectives = clientDirectives;
+    this.compressHTML = compressHTML;
+    this.i18n = i18n;
+    this.middleware = middleware;
+    this.routeCache = routeCache;
+    this.site = site;
+    this.internalMiddleware = [
+      createI18nMiddleware(i18n, manifest.base, manifest.trailingSlash, manifest.buildFormat)
+    ];
+  }
+  internalMiddleware;
+}
+
+class AppPipeline extends Pipeline {
+  static create({
+    logger,
+    manifest,
+    mode,
+    renderers,
+    resolve,
+    serverLike,
+    streaming
+  }) {
+    return new AppPipeline(logger, manifest, mode, renderers, resolve, serverLike, streaming);
+  }
+  headElements(routeData) {
+    const routeInfo = this.manifest.routes.find((route) => route.routeData === routeData);
+    const links = /* @__PURE__ */ new Set();
+    const scripts = /* @__PURE__ */ new Set();
+    const styles = createStylesheetElementSet(routeInfo?.styles ?? []);
+    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));
+      }
+    }
+    return { links, styles, scripts };
+  }
+  componentMetadata() {
+  }
+}
+
+async function callMiddleware(onRequest, apiContext, responseFunction) {
+  let nextCalled = false;
+  let responseFunctionPromise = void 0;
+  const next = async () => {
+    nextCalled = true;
+    responseFunctionPromise = responseFunction();
+    return responseFunctionPromise;
   };
-  Object.defineProperty(context, "locals", {
-    enumerable: true,
-    get() {
-      return Reflect.get(request, clientLocalsSymbol$1);
-    },
-    set(val) {
-      if (typeof val !== "object") {
-        throw new AstroError(LocalsNotAnObject);
+  let middlewarePromise = onRequest(apiContext, next);
+  return await Promise.resolve(middlewarePromise).then(async (value) => {
+    if (nextCalled) {
+      if (typeof value !== "undefined") {
+        if (value instanceof Response === false) {
+          throw new AstroError(MiddlewareNotAResponse);
+        }
+        return value;
       } else {
-        Reflect.set(request, clientLocalsSymbol$1, val);
+        if (responseFunctionPromise) {
+          return responseFunctionPromise;
+        } else {
+          throw new AstroError(MiddlewareNotAResponse);
+        }
       }
+    } else if (typeof value === "undefined") {
+      throw new AstroError(MiddlewareNoDataOrNextCalled);
+    } else if (value instanceof Response === false) {
+      throw new AstroError(MiddlewareNotAResponse);
+    } else {
+      return value;
     }
   });
-  return context;
 }
+
+function sequence(...handlers) {
+  const filtered = handlers.filter((h) => !!h);
+  const length = filtered.length;
+  if (!length) {
+    const handler = defineMiddleware((context, next) => {
+      return next();
+    });
+    return handler;
+  }
+  return defineMiddleware((context, next) => {
+    return applyHandle(0, context);
+    function applyHandle(i, handleContext) {
+      const handle = filtered[i];
+      const result = handle(handleContext, async () => {
+        if (i < length - 1) {
+          return applyHandle(i + 1, handleContext);
+        } else {
+          return next();
+        }
+      });
+      return result;
+    }
+  });
+}
+
 function parseLocale(header) {
   if (header === "*") {
     return [{ locale: header, qualityValue: void 0 }];
@@ -952,262 +974,124 @@ function computePreferredLocaleList(request, locales) {
           return locale;
         } else {
           return locale.codes.at(0);
-        }
-      });
-    } else if (browserLocaleList.length > 0) {
-      for (const browserLocale of browserLocaleList) {
-        for (const loopLocale of locales) {
-          if (typeof loopLocale === "string") {
-            if (normalizeTheLocale(loopLocale) === normalizeTheLocale(browserLocale.locale)) {
-              result.push(loopLocale);
-            }
-          } else {
-            for (const code of loopLocale.codes) {
-              if (code === browserLocale.locale) {
-                result.push(loopLocale.path);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  return result;
-}
-function computeCurrentLocale(request, locales, routingStrategy, defaultLocale) {
-  const routeData = Reflect.get(request, routeDataSymbol);
-  if (!routeData) {
-    return defaultLocale;
-  }
-  for (const segment of routeData.route.split("/")) {
-    for (const locale of locales) {
-      if (typeof locale === "string") {
-        if (normalizeTheLocale(locale) === normalizeTheLocale(segment)) {
-          return locale;
-        }
-      } else {
-        if (locale.path === segment) {
-          return locale.codes.at(0);
-        }
-      }
-    }
-  }
-  if (routingStrategy === "pathname-prefix-other-locales" || routingStrategy === "domains-prefix-other-locales") {
-    return defaultLocale;
-  }
-  return void 0;
-}
-
-function createEnvironment(options) {
-  return options;
-}
-
-const clientAddressSymbol$3 = Symbol.for("astro.clientAddress");
-const clientLocalsSymbol = Symbol.for("astro.locals");
-function createAPIContext({
-  request,
-  params,
-  site,
-  props,
-  adapterName,
-  locales,
-  routingStrategy,
-  defaultLocale
-}) {
-  let preferredLocale = void 0;
-  let preferredLocaleList = void 0;
-  let currentLocale = void 0;
-  const context = {
-    cookies: new AstroCookies(request),
-    request,
-    params,
-    site: site ? new URL(site) : void 0,
-    generator: `Astro v${ASTRO_VERSION}`,
-    props,
-    redirect(path, status) {
-      return new Response(null, {
-        status: status || 302,
-        headers: {
-          Location: path
-        }
-      });
-    },
-    get preferredLocale() {
-      if (preferredLocale) {
-        return preferredLocale;
-      }
-      if (locales) {
-        preferredLocale = computePreferredLocale(request, locales);
-        return preferredLocale;
-      }
-      return void 0;
-    },
-    get preferredLocaleList() {
-      if (preferredLocaleList) {
-        return preferredLocaleList;
-      }
-      if (locales) {
-        preferredLocaleList = computePreferredLocaleList(request, locales);
-        return preferredLocaleList;
-      }
-      return void 0;
-    },
-    get currentLocale() {
-      if (currentLocale) {
-        return currentLocale;
-      }
-      if (locales) {
-        currentLocale = computeCurrentLocale(request, locales, routingStrategy, defaultLocale);
-      }
-      return currentLocale;
-    },
-    url: new URL(request.url),
-    get clientAddress() {
-      if (clientAddressSymbol$3 in request) {
-        return Reflect.get(request, clientAddressSymbol$3);
-      }
-      if (adapterName) {
-        throw new AstroError({
-          ...ClientAddressNotAvailable,
-          message: ClientAddressNotAvailable.message(adapterName)
-        });
-      } else {
-        throw new AstroError(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(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(LocalsNotAnObject);
-      } else {
-        Reflect.set(request, clientLocalsSymbol, val);
+        }
+      });
+    } else if (browserLocaleList.length > 0) {
+      for (const browserLocale of browserLocaleList) {
+        for (const loopLocale of locales) {
+          if (typeof loopLocale === "string") {
+            if (normalizeTheLocale(loopLocale) === normalizeTheLocale(browserLocale.locale)) {
+              result.push(loopLocale);
+            }
+          } else {
+            for (const code of loopLocale.codes) {
+              if (code === browserLocale.locale) {
+                result.push(loopLocale.path);
+              }
+            }
+          }
+        }
       }
     }
-  };
-  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;
+  return result;
 }
-
-function sequence(...handlers) {
-  const filtered = handlers.filter((h) => !!h);
-  const length = filtered.length;
-  if (!length) {
-    const handler = defineMiddleware((context, next) => {
-      return next();
-    });
-    return handler;
-  }
-  return defineMiddleware((context, next) => {
-    return applyHandle(0, context);
-    function applyHandle(i, handleContext) {
-      const handle = filtered[i];
-      const result = handle(handleContext, async () => {
-        if (i < length - 1) {
-          return applyHandle(i + 1, handleContext);
+function computeCurrentLocale(pathname, locales, routingStrategy, defaultLocale) {
+  for (const segment of pathname.split("/")) {
+    for (const locale of locales) {
+      if (typeof locale === "string") {
+        if (!segment.includes(locale))
+          continue;
+        if (normalizeTheLocale(locale) === normalizeTheLocale(segment)) {
+          return locale;
+        }
+      } else {
+        if (locale.path === segment) {
+          return locale.codes.at(0);
         } else {
-          return next();
+          for (const code of locale.codes) {
+            if (normalizeTheLocale(code) === normalizeTheLocale(segment)) {
+              return code;
+            }
+          }
         }
-      });
-      return result;
+      }
     }
-  });
+  }
+  if (routingStrategy === "pathname-prefix-other-locales" || routingStrategy === "domains-prefix-other-locales") {
+    return defaultLocale;
+  }
+  return void 0;
 }
 
 function defineMiddleware(fn) {
   return fn;
 }
 
-function createAssetLink(href, base, assetsPrefix) {
-  if (assetsPrefix) {
-    return joinPaths(assetsPrefix, slash(href));
-  } else if (base) {
-    return prependForwardSlash$1(joinPaths(base, slash(href)));
-  } else {
-    return href;
+async function getProps(opts) {
+  const { logger, mod, routeData: route, routeCache, pathname, serverLike } = opts;
+  if (!route || route.pathname) {
+    return {};
   }
-}
-function createStylesheetElement(stylesheet, base, assetsPrefix) {
-  if (stylesheet.type === "inline") {
-    return {
-      props: {},
-      children: stylesheet.content
-    };
-  } else {
-    return {
-      props: {
-        rel: "stylesheet",
-        href: createAssetLink(stylesheet.src, base, assetsPrefix)
-      },
-      children: ""
-    };
+  if (routeIsRedirect(route) || routeIsFallback(route)) {
+    return {};
   }
-}
-function createStylesheetElementSet(stylesheets, base, assetsPrefix) {
-  return new Set(stylesheets.map((s) => createStylesheetElement(s, base, assetsPrefix)));
-}
-function createModuleScriptElement(script, base, assetsPrefix) {
-  if (script.type === "external") {
-    return createModuleScriptElementWithSrc(script.value, base, assetsPrefix);
-  } else {
-    return {
-      props: {
-        type: "module"
-      },
-      children: script.value
-    };
+  const params = getParams(route, pathname);
+  if (mod) {
+    validatePrerenderEndpointCollision(route, mod, params);
   }
-}
-function createModuleScriptElementWithSrc(src, base, assetsPrefix) {
-  return {
-    props: {
-      type: "module",
-      src: createAssetLink(src, base, assetsPrefix)
-    },
-    children: ""
-  };
-}
-
-function matchRoute(pathname, manifest) {
-  const decodedPathname = decodeURI(pathname);
-  return manifest.routes.find((route) => {
-    return route.pattern.test(decodedPathname) || route.fallbackRoutes.some((fallbackRoute) => fallbackRoute.pattern.test(decodedPathname));
+  const staticPaths = await callGetStaticPaths({
+    mod,
+    route,
+    routeCache,
+    logger,
+    ssr: serverLike
+  });
+  const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
+  if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
+    throw new AstroError({
+      ...NoMatchingStaticPathFound,
+      message: NoMatchingStaticPathFound.message(pathname),
+      hint: NoMatchingStaticPathFound.hint([route.component])
+    });
+  }
+  const props = matchedStaticPath?.props ? { ...matchedStaticPath.props } : {};
+  return props;
+}
+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) {
+    const lastSegment = route.segments[route.segments.length - 1];
+    const paramValues = Object.values(params);
+    const lastParam = paramValues[paramValues.length - 1];
+    if (lastSegment.length === 1 && lastSegment[0].dynamic && lastParam === void 0) {
+      throw new AstroError({
+        ...PrerenderDynamicEndpointPathCollide,
+        message: PrerenderDynamicEndpointPathCollide.message(route.route),
+        hint: PrerenderDynamicEndpointPathCollide.hint(route.component),
+        location: {
+          file: route.component
+        }
+      });
+    }
+  }
 }
 
-const clientAddressSymbol$2 = Symbol.for("astro.clientAddress");
-const responseSentSymbol$1 = Symbol.for("astro.responseSent");
 function getFunctionExpression(slot) {
   if (!slot)
     return;
@@ -1312,7 +1196,7 @@ function createResult(args) {
         // @ts-expect-error
         __proto__: astroGlobal,
         get clientAddress() {
-          if (!(clientAddressSymbol$2 in request)) {
+          if (!(clientAddressSymbol$1 in request)) {
             if (args.adapterName) {
               throw new AstroError({
                 ...ClientAddressNotAvailable,
@@ -1322,7 +1206,7 @@ function createResult(args) {
               throw new AstroError(StaticClientAddressNotAvailable);
             }
           }
-          return Reflect.get(request, clientAddressSymbol$2);
+          return Reflect.get(request, clientAddressSymbol$1);
         },
         get cookies() {
           if (cookies) {
@@ -1358,9 +1242,9 @@ function createResult(args) {
           }
           if (args.locales) {
             currentLocale = computeCurrentLocale(
-              request,
+              url.pathname,
               args.locales,
-              args.routingStrategy,
+              args.strategy,
               args.defaultLocale
             );
             if (currentLocale) {
@@ -1407,177 +1291,205 @@ function createResult(args) {
   return result;
 }
 
-async function renderPage({ mod, renderContext, env, cookies }) {
-  if (routeIsRedirect(renderContext.route)) {
-    return new Response(null, {
-      status: redirectRouteStatus(renderContext.route, renderContext.request.method),
-      headers: {
-        location: redirectRouteGenerate(renderContext.route, renderContext.params)
-      }
-    });
-  } else if (routeIsFallback(renderContext.route)) {
-    return new Response(null, {
-      status: 404
-    });
-  } else if (!mod) {
-    throw new AstroError(CantRenderPage);
-  }
-  const Component = mod.default;
-  if (!Component)
-    throw new Error(`Expected an exported Astro component but received typeof ${typeof Component}`);
-  const result = createResult({
-    adapterName: env.adapterName,
-    links: renderContext.links,
-    styles: renderContext.styles,
-    logger: env.logger,
-    params: renderContext.params,
-    pathname: renderContext.pathname,
-    componentMetadata: renderContext.componentMetadata,
-    resolve: env.resolve,
-    renderers: env.renderers,
-    clientDirectives: env.clientDirectives,
-    compressHTML: env.compressHTML,
-    request: renderContext.request,
-    partial: !!mod.partial,
-    site: env.site,
-    scripts: renderContext.scripts,
-    ssr: env.ssr,
-    status: renderContext.status ?? 200,
-    cookies,
-    locals: renderContext.locals ?? {},
-    locales: renderContext.locales,
-    defaultLocale: renderContext.defaultLocale,
-    routingStrategy: renderContext.routing
-  });
-  const response = await renderPage$1(
-    result,
-    Component,
-    renderContext.props,
-    {},
-    env.streaming,
-    renderContext.route
-  );
-  if (result.cookies) {
-    attachCookiesToResponse(response, result.cookies);
-  }
-  return response;
-}
-
-class Pipeline {
-  env;
-  #onRequest;
-  #hooks = {
-    before: []
-  };
-  /**
-   * When creating a pipeline, an environment is mandatory.
-   * The environment won't change for the whole lifetime of the pipeline.
-   */
-  constructor(env) {
-    this.env = env;
-  }
-  setEnvironment() {
-  }
-  /**
-   * A middleware function that will be called before each request.
-   */
-  setMiddlewareFunction(onRequest) {
-    this.#onRequest = onRequest;
-  }
-  /**
-   * Removes the current middleware function. Subsequent requests won't trigger any middleware.
-   */
-  unsetMiddlewareFunction() {
-    this.#onRequest = void 0;
-  }
-  /**
-   * Returns the current environment
-   */
-  getEnvironment() {
-    return this.env;
-  }
-  /**
-   * The main function of the pipeline. Use this function to render any route known to Astro;
-   */
-  async renderRoute(renderContext, componentInstance) {
-    for (const hook of this.#hooks.before) {
-      hook(renderContext, componentInstance);
-    }
-    return await this.#tryRenderRoute(renderContext, this.env, componentInstance, this.#onRequest);
+class RenderContext {
+  constructor(pipeline, locals, middleware, pathname, request, routeData, status, cookies = new AstroCookies(request), params = getParams(routeData, pathname)) {
+    this.pipeline = pipeline;
+    this.locals = locals;
+    this.middleware = middleware;
+    this.pathname = pathname;
+    this.request = request;
+    this.routeData = routeData;
+    this.status = status;
+    this.cookies = cookies;
+    this.params = params;
+  }
+  static create({
+    locals = {},
+    middleware,
+    pathname,
+    pipeline,
+    request,
+    routeData,
+    status = 200
+  }) {
+    return new RenderContext(
+      pipeline,
+      locals,
+      sequence(...pipeline.internalMiddleware, middleware ?? pipeline.middleware),
+      pathname,
+      request,
+      routeData,
+      status
+    );
   }
   /**
+   * 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
-   *
-   * ## Errors
-   *
-   * It throws an error if the page can't be rendered.
+   * - fallback
    */
-  async #tryRenderRoute(renderContext, env, mod, onRequest) {
-    const apiContext = createAPIContext({
-      request: renderContext.request,
-      params: renderContext.params,
-      props: renderContext.props,
-      site: env.site,
-      adapterName: env.adapterName,
-      locales: renderContext.locales,
-      routingStrategy: renderContext.routing,
-      defaultLocale: renderContext.defaultLocale
+  async render(componentInstance) {
+    const { cookies, middleware, pathname, pipeline, routeData } = this;
+    const { logger, routeCache, serverLike, streaming } = pipeline;
+    const props = await getProps({
+      mod: componentInstance,
+      routeData,
+      routeCache,
+      pathname,
+      logger,
+      serverLike
     });
-    switch (renderContext.route.type) {
-      case "page":
-      case "fallback":
-      case "redirect": {
-        if (onRequest) {
-          return await callMiddleware(onRequest, apiContext, () => {
-            return renderPage({
-              mod,
-              renderContext,
-              env,
-              cookies: apiContext.cookies
-            });
+    const apiContext = this.createAPIContext(props);
+    const { type } = routeData;
+    const lastNext = type === "endpoint" ? () => renderEndpoint(componentInstance, apiContext, serverLike, logger) : type === "redirect" ? () => renderRedirect(this) : type === "page" ? async () => {
+      const result = await this.createResult(componentInstance);
+      const response2 = await renderPage(
+        result,
+        componentInstance?.default,
+        props,
+        {},
+        streaming,
+        routeData
+      );
+      response2.headers.set(ROUTE_TYPE_HEADER, "page");
+      return response2;
+    } : type === "fallback" ? () => new Response(null, { status: 500, headers: { [ROUTE_TYPE_HEADER]: "fallback" } }) : () => {
+      throw new Error("Unknown type of route: " + type);
+    };
+    const response = await callMiddleware(middleware, apiContext, lastNext);
+    if (response.headers.get(ROUTE_TYPE_HEADER)) {
+      response.headers.delete(ROUTE_TYPE_HEADER);
+    }
+    attachCookiesToResponse(response, cookies);
+    return response;
+  }
+  createAPIContext(props) {
+    const renderContext = this;
+    const { cookies, i18nData, params, pipeline, request } = this;
+    const { currentLocale, preferredLocale, preferredLocaleList } = i18nData;
+    const generator = `Astro v${ASTRO_VERSION}`;
+    const redirect = (path, status = 302) => new Response(null, { status, headers: { Location: path } });
+    const site = pipeline.site ? new URL(pipeline.site) : void 0;
+    const url = new URL(request.url);
+    return {
+      cookies,
+      currentLocale,
+      generator,
+      params,
+      preferredLocale,
+      preferredLocaleList,
+      props,
+      redirect,
+      request,
+      site,
+      url,
+      get clientAddress() {
+        if (clientAddressSymbol$1 in request) {
+          return Reflect.get(request, clientAddressSymbol$1);
+        }
+        if (pipeline.adapterName) {
+          throw new AstroError({
+            ...ClientAddressNotAvailable,
+            message: ClientAddressNotAvailable.message(pipeline.adapterName)
           });
         } else {
-          return await renderPage({
-            mod,
-            renderContext,
-            env,
-            cookies: apiContext.cookies
-          });
+          throw new AstroError(StaticClientAddressNotAvailable);
+        }
+      },
+      get locals() {
+        return renderContext.locals;
+      },
+      // TODO(breaking): disallow replacing the locals object
+      set locals(val) {
+        if (typeof val !== "object") {
+          throw new AstroError(LocalsNotAnObject);
+        } else {
+          renderContext.locals = val;
+          Reflect.set(request, clientLocalsSymbol, val);
         }
       }
-      case "endpoint": {
-        return await callEndpoint(mod, env, renderContext, onRequest);
-      }
-      default:
-        throw new Error(`Couldn't find route of type [${renderContext.route.type}]`);
-    }
+    };
+  }
+  async createResult(mod) {
+    const { cookies, locals, params, pathname, pipeline, request, routeData, status } = this;
+    const {
+      adapterName,
+      clientDirectives,
+      compressHTML,
+      i18n,
+      manifest,
+      logger,
+      renderers,
+      resolve,
+      site,
+      serverLike
+    } = pipeline;
+    const { links, scripts, styles } = await pipeline.headElements(routeData);
+    const componentMetadata = await pipeline.componentMetadata(routeData) ?? manifest.componentMetadata;
+    const { defaultLocale, locales, strategy } = i18n ?? {};
+    const partial = Boolean(mod.partial);
+    return createResult({
+      adapterName,
+      clientDirectives,
+      componentMetadata,
+      compressHTML,
+      cookies,
+      defaultLocale,
+      locales,
+      locals,
+      logger,
+      links,
+      params,
+      partial,
+      pathname,
+      renderers,
+      resolve,
+      request,
+      route: routeData.route,
+      strategy,
+      site,
+      scripts,
+      ssr: serverLike,
+      status,
+      styles
+    });
   }
   /**
-   * Store a function that will be called before starting the rendering phase.
-   * @param fn
+   * API Context may be created multiple times per request, i18n data needs to be computed only once.
+   * So, it is computed and saved here on creation of the first APIContext and reused for later ones.
    */
-  onBeforeRenderRoute(fn) {
-    this.#hooks.before.push(fn);
+  #i18nData;
+  get i18nData() {
+    if (this.#i18nData)
+      return this.#i18nData;
+    const {
+      pipeline: { i18n },
+      request,
+      routeData
+    } = this;
+    if (!i18n)
+      return {
+        currentLocale: void 0,
+        preferredLocale: void 0,
+        preferredLocaleList: void 0
+      };
+    const { defaultLocale, locales, strategy } = i18n;
+    return this.#i18nData = {
+      currentLocale: computeCurrentLocale(routeData.route, locales, strategy, defaultLocale),
+      preferredLocale: computePreferredLocale(request, locales),
+      preferredLocaleList: computePreferredLocaleList(request, locales)
+    };
   }
 }
 
-class SSRRoutePipeline extends Pipeline {
-}
-
-const localsSymbol = Symbol.for("astro.locals");
-const clientAddressSymbol$1 = Symbol.for("astro.clientAddress");
-const responseSentSymbol = Symbol.for("astro.responseSent");
-const REROUTABLE_STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
 class App {
-  /**
-   * The current environment of the application
-   */
   #manifest;
   #manifestData;
-  #routeDataToRouteInfo;
   #logger = new Logger({
     dest: consoleLogDestination,
     level: "info"
@@ -1591,9 +1503,8 @@ class App {
     this.#manifestData = {
       routes: manifest.routes.map((route) => route.routeData)
     };
-    this.#routeDataToRouteInfo = new Map(manifest.routes.map((route) => [route.routeData, route]));
     this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#manifest.base);
-    this.#pipeline = new SSRRoutePipeline(this.#createEnvironment(streaming));
+    this.#pipeline = this.#createPipeline(streaming);
     this.#adapterLogger = new AstroIntegrationLogger(
       this.#logger.options,
       this.#manifest.adapterName
@@ -1603,19 +1514,17 @@ class App {
     return this.#adapterLogger;
   }
   /**
-   * Creates an environment by reading the stored manifest
+   * Creates a pipeline by reading the stored manifest
    *
    * @param streaming
    * @private
    */
-  #createEnvironment(streaming = false) {
-    return createEnvironment({
-      adapterName: this.#manifest.adapterName,
+  #createPipeline(streaming = false) {
+    return AppPipeline.create({
       logger: this.#logger,
+      manifest: this.#manifest,
       mode: "production",
-      compressHTML: this.#manifest.compressHTML,
       renderers: this.#manifest.renderers,
-      clientDirectives: this.#manifest.clientDirectives,
       resolve: async (specifier) => {
         if (!(specifier in this.#manifest.entryModules)) {
           throw new Error(`Unable to resolve [${specifier}]`);
@@ -1631,9 +1540,7 @@ class App {
           }
         }
       },
-      routeCache: new RouteCache(this.#logger),
-      site: this.#manifest.site,
-      ssr: true,
+      serverLike: true,
       streaming
     });
   }
@@ -1667,7 +1574,7 @@ class App {
   #computePathnameFromDomain(request) {
     let pathname = void 0;
     const url = new URL(request.url);
-    if (this.#manifest.i18n && (this.#manifest.i18n.routing === "domains-prefix-always" || this.#manifest.i18n.routing === "domains-prefix-other-locales" || this.#manifest.i18n.routing === "domains-prefix-other-no-redirect")) {
+    if (this.#manifest.i18n && (this.#manifest.i18n.strategy === "domains-prefix-always" || this.#manifest.i18n.strategy === "domains-prefix-other-locales" || this.#manifest.i18n.strategy === "domains-prefix-always-no-redirect")) {
       let host = request.headers.get("X-Forwarded-Host");
       let protocol = request.headers.get("X-Forwarded-Proto");
       if (protocol) {
@@ -1737,7 +1644,11 @@ class App {
       }
     }
     if (locals) {
-      Reflect.set(request, localsSymbol, locals);
+      if (typeof locals !== "object") {
+        this.#logger.error(null, new AstroError(LocalsNotAnObject).stack);
+        return this.#renderError(request, { status: 500 });
+      }
+      Reflect.set(request, clientLocalsSymbol, locals);
     }
     if (clientAddress) {
       Reflect.set(request, clientAddressSymbol$1, clientAddress);
@@ -1754,35 +1665,22 @@ class App {
     const pathname = this.#getPathnameFromRequest(request);
     const defaultStatus = this.#getDefaultStatusCode(routeData, pathname);
     const mod = await this.#getModuleForRoute(routeData);
-    const pageModule = await mod.page();
-    const url = new URL(request.url);
-    const renderContext = await this.#createRenderContext(
-      url,
-      request,
-      routeData,
-      mod,
-      defaultStatus
-    );
     let response;
     try {
-      const i18nMiddleware = createI18nMiddleware(
-        this.#manifest.i18n,
-        this.#manifest.base,
-        this.#manifest.trailingSlash,
-        this.#manifest.buildFormat
-      );
-      if (i18nMiddleware) {
-        this.#pipeline.setMiddlewareFunction(sequence(i18nMiddleware, this.#manifest.middleware));
-        this.#pipeline.onBeforeRenderRoute(i18nPipelineHook);
-      } else {
-        this.#pipeline.setMiddlewareFunction(this.#manifest.middleware);
-      }
-      response = await this.#pipeline.renderRoute(renderContext, pageModule);
+      const renderContext = RenderContext.create({
+        pipeline: this.#pipeline,
+        locals,
+        pathname,
+        request,
+        routeData,
+        status: defaultStatus
+      });
+      response = await renderContext.render(await mod.page());
     } catch (err) {
       this.#logger.error(null, err.stack || err.message || String(err));
       return this.#renderError(request, { status: 500 });
     }
-    if (REROUTABLE_STATUS_CODES.has(response.status) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
+    if (REROUTABLE_STATUS_CODES.includes(response.status) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
       return this.#renderError(request, {
         response,
         status: response.status
@@ -1796,7 +1694,7 @@ class App {
         response.headers.append("set-cookie", setCookieHeaderValue);
       }
     }
-    Reflect.set(response, responseSentSymbol, true);
+    Reflect.set(response, responseSentSymbol$1, true);
     return response;
   }
   #logRenderOptionsDeprecationWarning() {
@@ -1823,61 +1721,6 @@ class App {
    * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
    */
   static getSetCookieFromResponse = getSetCookiesFromResponse;
-  /**
-   * Creates the render context of the current route
-   */
-  async #createRenderContext(url, request, routeData, page, status = 200) {
-    if (routeData.type === "endpoint") {
-      const pathname = "/" + this.removeBase(url.pathname);
-      const mod = await page.page();
-      const handler = mod;
-      return await createRenderContext({
-        request,
-        pathname,
-        route: routeData,
-        status,
-        env: this.#pipeline.env,
-        mod: handler,
-        locales: this.#manifest.i18n?.locales,
-        routing: this.#manifest.i18n?.routing,
-        defaultLocale: this.#manifest.i18n?.defaultLocale
-      });
-    } else {
-      const pathname = prependForwardSlash$1(this.removeBase(url.pathname));
-      const info = this.#routeDataToRouteInfo.get(routeData);
-      const links = /* @__PURE__ */ new Set();
-      const styles = createStylesheetElementSet(info.styles);
-      let scripts = /* @__PURE__ */ new Set();
-      for (const script of info.scripts) {
-        if ("stage" in script) {
-          if (script.stage === "head-inline") {
-            scripts.add({
-              props: {},
-              children: script.children
-            });
-          }
-        } else {
-          scripts.add(createModuleScriptElement(script));
-        }
-      }
-      const mod = await page.page();
-      return await createRenderContext({
-        request,
-        pathname,
-        componentMetadata: this.#manifest.componentMetadata,
-        scripts,
-        styles,
-        links,
-        route: routeData,
-        status,
-        mod,
-        env: this.#pipeline.env,
-        locales: this.#manifest.i18n?.locales,
-        routing: this.#manifest.i18n?.routing,
-        defaultLocale: this.#manifest.i18n?.defaultLocale
-      });
-    }
-  }
   /**
    * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
    * This also handles pre-rendered /404 or /500 routes
@@ -1899,21 +1742,15 @@ class App {
       }
       const mod = await this.#getModuleForRoute(errorRouteData);
       try {
-        const newRenderContext = await this.#createRenderContext(
-          url,
+        const renderContext = RenderContext.create({
+          pipeline: this.#pipeline,
+          middleware: skipMiddleware ? (_, next) => next() : void 0,
+          pathname: this.#getPathnameFromRequest(request),
           request,
-          errorRouteData,
-          mod,
+          routeData: errorRouteData,
           status
-        );
-        const page = await mod.page();
-        if (skipMiddleware === false) {
-          this.#pipeline.setMiddlewareFunction(this.#manifest.middleware);
-        }
-        if (skipMiddleware) {
-          this.#pipeline.unsetMiddlewareFunction();
-        }
-        const response2 = await this.#pipeline.renderRoute(newRenderContext, page);
+        });
+        const response2 = await renderContext.render(await mod.page());
         return this.#mergeResponses(response2, originalResponse);
       } catch {
         if (skipMiddleware === false) {
@@ -1926,7 +1763,7 @@ class App {
       }
     }
     const response = this.#mergeResponses(new Response(null, { status }), originalResponse);
-    Reflect.set(response, responseSentSymbol, true);
+    Reflect.set(response, responseSentSymbol$1, true);
     return response;
   }
   #mergeResponses(newResponse, originalResponse, override) {
@@ -2436,19 +2273,21 @@ const serverEntrypointModule = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.de
   start
 }, Symbol.toStringTag, { value: 'Module' }));
 
-const _page0 = () => import('./chunks/node_zqXXqc-u.mjs');
-const _page1 = () => import('./chunks/~fallback_Wahcp9Wk.mjs');
-const _page2 = () => import('./chunks/index__05fnqFh.mjs');
-const _page3 = () => import('./chunks/account_vK6pmJlz.mjs');
-const _page4 = () => import('./chunks/_page__qqIVxbal.mjs');
-const _page5 = () => import('./chunks/_.._19fCuQdO.mjs');
+const _page0 = () => import('./chunks/node_C7sdLKL4.mjs');
+const _page1 = () => import('./chunks/~fallback_YpJa9BIL.mjs');
+const _page2 = () => import('./chunks/index_BTDpenpc.mjs');
+const _page3 = () => import('./chunks/account_CaTloREf.mjs');
+const _page4 = () => import('./chunks/index_D0q4ab_n.mjs');
+const _page5 = () => import('./chunks/_page__DU3kNewy.mjs');
+const _page6 = () => import('./chunks/_.._DORZHe_Z.mjs');
 const pageMap = new Map([
-    ["../../node_modules/.pnpm/astro@4.3.2_@types+node@18.19.14_typescript@5.2.2/node_modules/astro/dist/assets/endpoint/node.js", _page0],
+    ["../../node_modules/.pnpm/astro@4.4.4_@types+node@18.19.18_typescript@5.2.2/node_modules/astro/dist/assets/endpoint/node.js", _page0],
     ["src/pages/~fallback.astro", _page1],
-    ["src/pages/app/index.astro", _page2],
+    ["src/pages/admin/index.astro", _page2],
     ["src/pages/app/account.astro", _page3],
-    ["src/pages/blog/[page].astro", _page4],
-    ["src/pages/[...slug].astro", _page5]
+    ["src/pages/app/index.astro", _page4],
+    ["src/pages/blog/[page].astro", _page5],
+    ["src/pages/[...slug].astro", _page6]
 ]);
 
 const _manifest = Object.assign(manifest, {