cloudcommerce 0.20.2 → 0.22.0

package/packages/storefront/dist/server/chunks/{astro.45d3047f.mjs → astro.2d3ebf0f.mjs}

@@ -1,13 +1,13 @@
 import { compile } from 'path-to-regexp';
 import { serialize, parse } from 'cookie';
 import { joinPaths, slash, prependForwardSlash, removeTrailingForwardSlash } from '@astrojs/internal-helpers/path';
-import { bold, yellow, dim, cyan, red, reset } from 'kleur/colors';
-import 'fs';
-import 'http';
-import { TLSSocket } from 'tls';
+import { yellow, dim, bold, cyan, red, reset } from 'kleur/colors';
+import 'node:fs';
+import 'node:http';
+import { TLSSocket } from 'node:tls';
 import mime from 'mime';
-import { escape } from 'html-escaper';
 import 'string-width';
+import { escape } from 'html-escaper';
 
 const AstroErrorData = {
   /**
@@ -1115,7 +1115,7 @@ function validateArgs(args) {
     return false;
   return true;
 }
-function baseCreateComponent(cb, moduleId) {
+function baseCreateComponent(cb, moduleId, propagation) {
   var _a;
   const name = ((_a = moduleId == null ? void 0 : moduleId.split("/").pop()) == null ? void 0 : _a.replace(".astro", "")) ?? "";
   const fn = (...args) => {
@@ -1130,22 +1130,22 @@ function baseCreateComponent(cb, moduleId) {
   Object.defineProperty(fn, "name", { value: name, writable: false });
   fn.isAstroComponentFactory = true;
   fn.moduleId = moduleId;
+  fn.propagation = propagation;
   return fn;
 }
 function createComponentWithOptions(opts) {
-  const cb = baseCreateComponent(opts.factory, opts.moduleId);
-  cb.propagation = opts.propagation;
+  const cb = baseCreateComponent(opts.factory, opts.moduleId, opts.propagation);
   return cb;
 }
-function createComponent(arg1, moduleId) {
+function createComponent(arg1, moduleId, propagation) {
   if (typeof arg1 === "function") {
-    return baseCreateComponent(arg1, moduleId);
+    return baseCreateComponent(arg1, moduleId, propagation);
   } else {
     return createComponentWithOptions(arg1);
   }
 }
 
-const ASTRO_VERSION = "2.8.3";
+const ASTRO_VERSION = "2.9.0";
 
 function createAstroGlobFn() {
   const globHandler = (importMetaGlobResult) => {
@@ -3363,6 +3363,82 @@ if (typeof process !== "undefined") {
   }
 }
 
+let lastMessage;
+let lastMessageCount = 1;
+const consoleLogDestination = {
+  write(event) {
+    let dest = console.error;
+    if (levels[event.level] < levels["error"]) {
+      dest = console.log;
+    }
+    function getPrefix() {
+      let prefix = "";
+      let type = event.type;
+      if (type) {
+        prefix += dim(dateTimeFormat.format(/* @__PURE__ */ new Date()) + " ");
+        if (event.level === "info") {
+          type = bold(cyan(`[${type}]`));
+        } else if (event.level === "warn") {
+          type = bold(yellow(`[${type}]`));
+        } else if (event.level === "error") {
+          type = bold(red(`[${type}]`));
+        }
+        prefix += `${type} `;
+      }
+      return reset(prefix);
+    }
+    let message = event.message;
+    if (message === lastMessage) {
+      lastMessageCount++;
+      message = `${message} ${yellow(`(x${lastMessageCount})`)}`;
+    } else {
+      lastMessage = message;
+      lastMessageCount = 1;
+    }
+    const outMessage = getPrefix() + message;
+    dest(outMessage);
+    return true;
+  }
+};
+
+const RedirectComponentInstance = {
+  default() {
+    return new Response(null, {
+      status: 301
+    });
+  }
+};
+const RedirectSinglePageBuiltModule = {
+  page: () => Promise.resolve(RedirectComponentInstance),
+  onRequest: (ctx, next) => next(),
+  renderers: []
+};
+
+function routeIsRedirect(route) {
+  return (route == null ? void 0 : route.type) === "redirect";
+}
+function redirectRouteGenerate(redirectRoute, data) {
+  const routeData = redirectRoute.redirectRoute;
+  const route = redirectRoute.redirect;
+  if (typeof routeData !== "undefined") {
+    return (routeData == null ? void 0 : routeData.generate(data)) || (routeData == null ? void 0 : routeData.pathname) || "/";
+  } else if (typeof route === "string") {
+    return route;
+  } else if (typeof route === "undefined") {
+    return "/";
+  }
+  return route.destination;
+}
+function redirectRouteStatus(redirectRoute, method = "GET") {
+  const routeData = redirectRoute.redirectRoute;
+  if (typeof (routeData == null ? void 0 : routeData.redirect) === "object") {
+    return routeData.redirect.status;
+  } else if (method !== "GET") {
+    return 308;
+  }
+  return 301;
+}
+
 async function callMiddleware(logging, onRequest, apiContext, responseFunction) {
   let nextCalled = false;
   let responseFunctionPromise = void 0;
@@ -3514,139 +3590,335 @@ async function callEndpoint(mod, env, ctx, onRequest) {
   };
 }
 
-let lastMessage;
-let lastMessageCount = 1;
-const consoleLogDestination = {
-  write(event) {
-    let dest = console.error;
-    if (levels[event.level] < levels["error"]) {
-      dest = console.log;
-    }
-    function getPrefix() {
-      let prefix = "";
-      let type = event.type;
-      if (type) {
-        prefix += dim(dateTimeFormat.format(/* @__PURE__ */ new Date()) + " ");
-        if (event.level === "info") {
-          type = bold(cyan(`[${type}]`));
-        } else if (event.level === "warn") {
-          type = bold(yellow(`[${type}]`));
-        } else if (event.level === "error") {
-          type = bold(red(`[${type}]`));
+const clientAddressSymbol$1 = Symbol.for("astro.clientAddress");
+const responseSentSymbol$1 = Symbol.for("astro.responseSent");
+function getFunctionExpression(slot) {
+  var _a;
+  if (!slot)
+    return;
+  if (((_a = slot.expressions) == null ? void 0 : _a.length) !== 1)
+    return;
+  return slot.expressions[0];
+}
+class Slots {
+  #result;
+  #slots;
+  #loggingOpts;
+  constructor(result, slots, logging) {
+    this.#result = result;
+    this.#slots = slots;
+    this.#loggingOpts = logging;
+    if (slots) {
+      for (const key of Object.keys(slots)) {
+        if (this[key] !== void 0) {
+          throw new AstroError({
+            ...AstroErrorData.ReservedSlotName,
+            message: AstroErrorData.ReservedSlotName.message(key)
+          });
         }
-        prefix += `${type} `;
+        Object.defineProperty(this, key, {
+          get() {
+            return true;
+          },
+          enumerable: true
+        });
       }
-      return reset(prefix);
-    }
-    let message = event.message;
-    if (message === lastMessage) {
-      lastMessageCount++;
-      message = `${message} ${yellow(`(x${lastMessageCount})`)}`;
-    } else {
-      lastMessage = message;
-      lastMessageCount = 1;
     }
-    const outMessage = getPrefix() + message;
-    dest(outMessage);
-    return true;
-  }
-};
-
-const RedirectComponentInstance = {
-  default() {
-    return new Response(null, {
-      status: 301
-    });
-  }
-};
-const RedirectSinglePageBuiltModule = {
-  page: () => Promise.resolve(RedirectComponentInstance),
-  onRequest: (ctx, next) => next(),
-  renderers: []
-};
-
-function routeIsRedirect(route) {
-  return (route == null ? void 0 : route.type) === "redirect";
-}
-function redirectRouteGenerate(redirectRoute, data) {
-  const routeData = redirectRoute.redirectRoute;
-  const route = redirectRoute.redirect;
-  if (typeof routeData !== "undefined") {
-    return (routeData == null ? void 0 : routeData.generate(data)) || (routeData == null ? void 0 : routeData.pathname) || "/";
-  } else if (typeof route === "string") {
-    return route;
-  } else if (typeof route === "undefined") {
-    return "/";
   }
-  return route.destination;
-}
-function redirectRouteStatus(redirectRoute, method = "GET") {
-  const routeData = redirectRoute.redirectRoute;
-  if (typeof (routeData == null ? void 0 : routeData.redirect) === "object") {
-    return routeData.redirect.status;
-  } else if (method !== "GET") {
-    return 308;
+  has(name) {
+    if (!this.#slots)
+      return false;
+    return Boolean(this.#slots[name]);
   }
-  return 301;
-}
-
-const VALID_PARAM_TYPES = ["string", "number", "undefined"];
-function validateGetStaticPathsParameter([key, value], route) {
-  if (!VALID_PARAM_TYPES.includes(typeof value)) {
-    throw new AstroError({
-      ...AstroErrorData.GetStaticPathsInvalidRouteParam,
-      message: AstroErrorData.GetStaticPathsInvalidRouteParam.message(key, value, typeof value),
-      location: {
-        file: route
+  async render(name, args = []) {
+    if (!this.#slots || !this.has(name))
+      return;
+    const result = this.#result;
+    if (!Array.isArray(args)) {
+      warn(
+        this.#loggingOpts,
+        "Astro.slots.render",
+        `Expected second parameter to be an array, received a ${typeof args}. If you're trying to pass an array as a single argument and getting unexpected results, make sure you're passing your array as a item of an array. Ex: Astro.slots.render('default', [["Hello", "World"]])`
+      );
+    } else if (args.length > 0) {
+      const slotValue = this.#slots[name];
+      const component = typeof slotValue === "function" ? await slotValue(result) : await slotValue;
+      const expression = getFunctionExpression(component);
+      if (expression) {
+        const slot = async () => isHTMLString(await expression) ? expression : expression(...args);
+        return await renderSlotToString(result, slot).then((res) => {
+          return res != null ? String(res) : res;
+        });
       }
-    });
-  }
-}
-function validateDynamicRouteModule(mod, {
-  ssr,
-  logging,
-  route
-}) {
-  if (ssr && mod.getStaticPaths && !route.prerender) {
-    warn(
-      logging,
-      "getStaticPaths",
-      `getStaticPaths() in ${bold(route.component)} is ignored when "output: server" is set.`
-    );
-  }
-  if ((!ssr || route.prerender) && !mod.getStaticPaths) {
-    throw new AstroError({
-      ...AstroErrorData.GetStaticPathsRequired,
-      location: { file: route.component }
-    });
-  }
-}
-function validateGetStaticPathsResult(result, logging, route) {
-  if (!Array.isArray(result)) {
-    throw new AstroError({
-      ...AstroErrorData.InvalidGetStaticPathsReturn,
-      message: AstroErrorData.InvalidGetStaticPathsReturn.message(typeof result),
-      location: {
-        file: route.component
+      if (typeof component === "function") {
+        return await renderJSX(result, component(...args)).then(
+          (res) => res != null ? String(res) : res
+        );
       }
-    });
-  }
-  result.forEach((pathObject) => {
-    if (pathObject.params === void 0 || pathObject.params === null || pathObject.params && Object.keys(pathObject.params).length === 0) {
-      throw new AstroError({
-        ...AstroErrorData.GetStaticPathsExpectedParams,
-        location: {
-          file: route.component
-        }
-      });
     }
-    if (typeof pathObject.params !== "object") {
-      throw new AstroError({
-        ...AstroErrorData.InvalidGetStaticPathParam,
-        message: AstroErrorData.InvalidGetStaticPathParam.message(typeof pathObject.params),
-        location: {
-          file: route.component
-        }
+    const content = await renderSlotToString(result, this.#slots[name]);
+    const outHTML = stringifyChunk(result, content);
+    return outHTML;
+  }
+}
+let renderMarkdown = null;
+function createResult(args) {
+  const { markdown, params, request, resolve, locals } = args;
+  const url = new URL(request.url);
+  const headers = new Headers();
+  headers.set("Content-Type", "text/html");
+  const response = {
+    status: args.status,
+    statusText: "OK",
+    headers
+  };
+  Object.defineProperty(response, "headers", {
+    value: response.headers,
+    enumerable: true,
+    writable: false
+  });
+  let cookies = args.cookies;
+  const result = {
+    styles: args.styles ?? /* @__PURE__ */ new Set(),
+    scripts: args.scripts ?? /* @__PURE__ */ new Set(),
+    links: args.links ?? /* @__PURE__ */ new Set(),
+    componentMetadata: args.componentMetadata ?? /* @__PURE__ */ new Map(),
+    renderers: args.renderers,
+    clientDirectives: args.clientDirectives,
+    compressHTML: args.compressHTML,
+    pathname: args.pathname,
+    cookies,
+    /** This function returns the `Astro` faux-global */
+    createAstro(astroGlobal, props, slots) {
+      const astroSlots = new Slots(result, slots, args.logging);
+      const Astro = {
+        // @ts-expect-error
+        __proto__: astroGlobal,
+        get clientAddress() {
+          if (!(clientAddressSymbol$1 in request)) {
+            if (args.adapterName) {
+              throw new AstroError({
+                ...AstroErrorData.ClientAddressNotAvailable,
+                message: AstroErrorData.ClientAddressNotAvailable.message(args.adapterName)
+              });
+            } else {
+              throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
+            }
+          }
+          return Reflect.get(request, clientAddressSymbol$1);
+        },
+        get cookies() {
+          if (cookies) {
+            return cookies;
+          }
+          cookies = new AstroCookies(request);
+          result.cookies = cookies;
+          return cookies;
+        },
+        params,
+        props,
+        locals,
+        request,
+        url,
+        redirect(path, status) {
+          if (request[responseSentSymbol$1]) {
+            throw new AstroError({
+              ...AstroErrorData.ResponseSentError
+            });
+          }
+          return new Response(null, {
+            status: status || 302,
+            headers: {
+              Location: path
+            }
+          });
+        },
+        response,
+        slots: astroSlots
+      };
+      Object.defineProperty(Astro, "__renderMarkdown", {
+        // Ensure this API is not exposed to users
+        enumerable: false,
+        writable: false,
+        // TODO: Remove this hole "Deno" logic once our plugin gets Deno support
+        value: async function(content, opts) {
+          if (typeof Deno !== "undefined") {
+            throw new Error("Markdown is not supported in Deno SSR");
+          }
+          if (!renderMarkdown) {
+            let astroRemark = "@astrojs/";
+            astroRemark += "markdown-remark";
+            renderMarkdown = (await import(astroRemark)).renderMarkdown;
+          }
+          const { code } = await renderMarkdown(content, { ...markdown, ...opts ?? {} });
+          return code;
+        }
+      });
+      return Astro;
+    },
+    resolve,
+    response,
+    _metadata: {
+      hasHydrationScript: false,
+      hasRenderedHead: false,
+      hasDirectives: /* @__PURE__ */ new Set(),
+      headInTree: false,
+      extraHead: [],
+      propagators: /* @__PURE__ */ new Map()
+    }
+  };
+  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)
+      }
+    });
+  }
+  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,
+    logging: env.logging,
+    markdown: env.markdown,
+    params: renderContext.params,
+    pathname: renderContext.pathname,
+    componentMetadata: renderContext.componentMetadata,
+    resolve: env.resolve,
+    renderers: env.renderers,
+    clientDirectives: env.clientDirectives,
+    compressHTML: env.compressHTML,
+    request: renderContext.request,
+    site: env.site,
+    scripts: renderContext.scripts,
+    ssr: env.ssr,
+    status: renderContext.status ?? 200,
+    cookies,
+    locals: renderContext.locals ?? {}
+  });
+  if (typeof mod.components === "object") {
+    Object.assign(renderContext.props, { components: mod.components });
+  }
+  let response = await renderPage$1(
+    result,
+    Component,
+    renderContext.props,
+    null,
+    env.streaming,
+    renderContext.route
+  );
+  if (result.cookies) {
+    attachToResponse(response, result.cookies);
+  }
+  return response;
+}
+async function tryRenderRoute(routeType, renderContext, env, mod, onRequest) {
+  const apiContext = createAPIContext({
+    request: renderContext.request,
+    params: renderContext.params,
+    props: renderContext.props,
+    site: env.site,
+    adapterName: env.adapterName
+  });
+  switch (routeType) {
+    case "page":
+    case "redirect": {
+      if (onRequest) {
+        return await callMiddleware(
+          env.logging,
+          onRequest,
+          apiContext,
+          () => {
+            return renderPage({
+              mod,
+              renderContext,
+              env,
+              cookies: apiContext.cookies
+            });
+          }
+        );
+      } else {
+        return await renderPage({
+          mod,
+          renderContext,
+          env,
+          cookies: apiContext.cookies
+        });
+      }
+    }
+    case "endpoint": {
+      const result = await callEndpoint(
+        mod,
+        env,
+        renderContext,
+        onRequest
+      );
+      return result;
+    }
+    default:
+      throw new Error(`Couldn't find route of type [${routeType}]`);
+  }
+}
+function isResponse(result, routeType) {
+  return result instanceof Response && (routeType === "page" || routeType === "redirect");
+}
+
+const VALID_PARAM_TYPES = ["string", "number", "undefined"];
+function validateGetStaticPathsParameter([key, value], route) {
+  if (!VALID_PARAM_TYPES.includes(typeof value)) {
+    throw new AstroError({
+      ...AstroErrorData.GetStaticPathsInvalidRouteParam,
+      message: AstroErrorData.GetStaticPathsInvalidRouteParam.message(key, value, typeof value),
+      location: {
+        file: route
+      }
+    });
+  }
+}
+function validateDynamicRouteModule(mod, {
+  ssr,
+  route
+}) {
+  if ((!ssr || route.prerender) && !mod.getStaticPaths) {
+    throw new AstroError({
+      ...AstroErrorData.GetStaticPathsRequired,
+      location: { file: route.component }
+    });
+  }
+}
+function validateGetStaticPathsResult(result, logging, route) {
+  if (!Array.isArray(result)) {
+    throw new AstroError({
+      ...AstroErrorData.InvalidGetStaticPathsReturn,
+      message: AstroErrorData.InvalidGetStaticPathsReturn.message(typeof result),
+      location: {
+        file: route.component
+      }
+    });
+  }
+  result.forEach((pathObject) => {
+    if (pathObject.params === void 0 || pathObject.params === null || pathObject.params && Object.keys(pathObject.params).length === 0) {
+      throw new AstroError({
+        ...AstroErrorData.GetStaticPathsExpectedParams,
+        location: {
+          file: route.component
+        }
+      });
+    }
+    if (typeof pathObject.params !== "object") {
+      throw new AstroError({
+        ...AstroErrorData.InvalidGetStaticPathParam,
+        message: AstroErrorData.InvalidGetStaticPathParam.message(typeof pathObject.params),
+        location: {
+          file: route.component
+        }
       });
     }
     for (const [key, val] of Object.entries(pathObject.params)) {
@@ -3684,14 +3956,14 @@ function getParams(array) {
   };
   return fn;
 }
-function stringifyParams(params, routeComponent) {
+function stringifyParams(params, route) {
   const validatedParams = Object.entries(params).reduce((acc, next) => {
-    validateGetStaticPathsParameter(next, routeComponent);
+    validateGetStaticPathsParameter(next, route.component);
     const [key, value] = next;
     acc[key] = value == null ? void 0 : value.toString();
     return acc;
   }, {});
-  return JSON.stringify(validatedParams, Object.keys(params).sort());
+  return JSON.stringify(route.generate(validatedParams));
 }
 
 function generatePaginateFunction(routeMatch) {
@@ -3767,7 +4039,7 @@ async function callGetStaticPaths({
   const cached = routeCache.get(route);
   if (cached == null ? void 0 : cached.staticPaths)
     return cached.staticPaths;
-  validateDynamicRouteModule(mod, { ssr, logging, route });
+  validateDynamicRouteModule(mod, { ssr, route });
   if (ssr && !route.prerender) {
     const entry = Object.assign([], { keyed: /* @__PURE__ */ new Map() });
     routeCache.set(route, { ...cached, staticPaths: entry });
@@ -3792,7 +4064,7 @@ async function callGetStaticPaths({
   const keyedStaticPaths = staticPaths;
   keyedStaticPaths.keyed = /* @__PURE__ */ new Map();
   for (const sp of keyedStaticPaths) {
-    const paramsKey = stringifyParams(sp.params, route.component);
+    const paramsKey = stringifyParams(sp.params, route);
     keyedStaticPaths.keyed.set(paramsKey, sp);
   }
   routeCache.set(route, { ...cached, staticPaths: keyedStaticPaths });
@@ -3824,7 +4096,7 @@ class RouteCache {
   }
 }
 function findPathItemByKey(staticPaths, params, route) {
-  const paramsKey = stringifyParams(params, route.component);
+  const paramsKey = stringifyParams(params, route);
   const matchedStaticPath = staticPaths.keyed.get(paramsKey);
   if (matchedStaticPath) {
     return matchedStaticPath;
@@ -3918,238 +4190,8 @@ async function createRenderContext(options) {
   return context;
 }
 
-const clientAddressSymbol$1 = Symbol.for("astro.clientAddress");
-const responseSentSymbol$1 = Symbol.for("astro.responseSent");
-function getFunctionExpression(slot) {
-  var _a;
-  if (!slot)
-    return;
-  if (((_a = slot.expressions) == null ? void 0 : _a.length) !== 1)
-    return;
-  return slot.expressions[0];
-}
-class Slots {
-  #result;
-  #slots;
-  #loggingOpts;
-  constructor(result, slots, logging) {
-    this.#result = result;
-    this.#slots = slots;
-    this.#loggingOpts = logging;
-    if (slots) {
-      for (const key of Object.keys(slots)) {
-        if (this[key] !== void 0) {
-          throw new AstroError({
-            ...AstroErrorData.ReservedSlotName,
-            message: AstroErrorData.ReservedSlotName.message(key)
-          });
-        }
-        Object.defineProperty(this, key, {
-          get() {
-            return true;
-          },
-          enumerable: true
-        });
-      }
-    }
-  }
-  has(name) {
-    if (!this.#slots)
-      return false;
-    return Boolean(this.#slots[name]);
-  }
-  async render(name, args = []) {
-    if (!this.#slots || !this.has(name))
-      return;
-    const result = this.#result;
-    if (!Array.isArray(args)) {
-      warn(
-        this.#loggingOpts,
-        "Astro.slots.render",
-        `Expected second parameter to be an array, received a ${typeof args}. If you're trying to pass an array as a single argument and getting unexpected results, make sure you're passing your array as a item of an array. Ex: Astro.slots.render('default', [["Hello", "World"]])`
-      );
-    } else if (args.length > 0) {
-      const slotValue = this.#slots[name];
-      const component = typeof slotValue === "function" ? await slotValue(result) : await slotValue;
-      const expression = getFunctionExpression(component);
-      if (expression) {
-        const slot = async () => isHTMLString(await expression) ? expression : expression(...args);
-        return await renderSlotToString(result, slot).then((res) => {
-          return res != null ? String(res) : res;
-        });
-      }
-      if (typeof component === "function") {
-        return await renderJSX(result, component(...args)).then(
-          (res) => res != null ? String(res) : res
-        );
-      }
-    }
-    const content = await renderSlotToString(result, this.#slots[name]);
-    const outHTML = stringifyChunk(result, content);
-    return outHTML;
-  }
-}
-let renderMarkdown = null;
-function createResult(args) {
-  const { markdown, params, request, resolve, locals } = args;
-  const url = new URL(request.url);
-  const headers = new Headers();
-  headers.set("Content-Type", "text/html");
-  const response = {
-    status: args.status,
-    statusText: "OK",
-    headers
-  };
-  Object.defineProperty(response, "headers", {
-    value: response.headers,
-    enumerable: true,
-    writable: false
-  });
-  let cookies = args.cookies;
-  const result = {
-    styles: args.styles ?? /* @__PURE__ */ new Set(),
-    scripts: args.scripts ?? /* @__PURE__ */ new Set(),
-    links: args.links ?? /* @__PURE__ */ new Set(),
-    componentMetadata: args.componentMetadata ?? /* @__PURE__ */ new Map(),
-    renderers: args.renderers,
-    clientDirectives: args.clientDirectives,
-    compressHTML: args.compressHTML,
-    pathname: args.pathname,
-    cookies,
-    /** This function returns the `Astro` faux-global */
-    createAstro(astroGlobal, props, slots) {
-      const astroSlots = new Slots(result, slots, args.logging);
-      const Astro = {
-        // @ts-expect-error
-        __proto__: astroGlobal,
-        get clientAddress() {
-          if (!(clientAddressSymbol$1 in request)) {
-            if (args.adapterName) {
-              throw new AstroError({
-                ...AstroErrorData.ClientAddressNotAvailable,
-                message: AstroErrorData.ClientAddressNotAvailable.message(args.adapterName)
-              });
-            } else {
-              throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
-            }
-          }
-          return Reflect.get(request, clientAddressSymbol$1);
-        },
-        get cookies() {
-          if (cookies) {
-            return cookies;
-          }
-          cookies = new AstroCookies(request);
-          result.cookies = cookies;
-          return cookies;
-        },
-        params,
-        props,
-        locals,
-        request,
-        url,
-        redirect(path, status) {
-          if (request[responseSentSymbol$1]) {
-            throw new AstroError({
-              ...AstroErrorData.ResponseSentError
-            });
-          }
-          return new Response(null, {
-            status: status || 302,
-            headers: {
-              Location: path
-            }
-          });
-        },
-        response,
-        slots: astroSlots
-      };
-      Object.defineProperty(Astro, "__renderMarkdown", {
-        // Ensure this API is not exposed to users
-        enumerable: false,
-        writable: false,
-        // TODO: Remove this hole "Deno" logic once our plugin gets Deno support
-        value: async function(content, opts) {
-          if (typeof Deno !== "undefined") {
-            throw new Error("Markdown is not supported in Deno SSR");
-          }
-          if (!renderMarkdown) {
-            let astroRemark = "@astrojs/";
-            astroRemark += "markdown-remark";
-            renderMarkdown = (await import(astroRemark)).renderMarkdown;
-          }
-          const { code } = await renderMarkdown(content, { ...markdown, ...opts ?? {} });
-          return code;
-        }
-      });
-      return Astro;
-    },
-    resolve,
-    response,
-    _metadata: {
-      hasHydrationScript: false,
-      hasRenderedHead: false,
-      hasDirectives: /* @__PURE__ */ new Set(),
-      headInTree: false,
-      extraHead: [],
-      propagators: /* @__PURE__ */ new Map()
-    }
-  };
-  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)
-      }
-    });
-  }
-  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,
-    logging: env.logging,
-    markdown: env.markdown,
-    params: renderContext.params,
-    pathname: renderContext.pathname,
-    componentMetadata: renderContext.componentMetadata,
-    resolve: env.resolve,
-    renderers: env.renderers,
-    clientDirectives: env.clientDirectives,
-    compressHTML: env.compressHTML,
-    request: renderContext.request,
-    site: env.site,
-    scripts: renderContext.scripts,
-    ssr: env.ssr,
-    status: renderContext.status ?? 200,
-    cookies,
-    locals: renderContext.locals ?? {}
-  });
-  if (typeof mod.components === "object") {
-    Object.assign(renderContext.props, { components: mod.components });
-  }
-  let response = await renderPage$1(
-    result,
-    Component,
-    renderContext.props,
-    null,
-    env.streaming,
-    renderContext.route
-  );
-  if (result.cookies) {
-    attachToResponse(response, result.cookies);
-  }
-  return response;
-}
-
-function createEnvironment(options) {
-  return options;
+function createEnvironment(options) {
+  return options;
 }
 
 function createAssetLink(href, base, assetsPrefix) {
@@ -4211,6 +4253,9 @@ function matchRoute(pathname, manifest) {
 const clientLocalsSymbol = Symbol.for("astro.locals");
 const responseSentSymbol = Symbol.for("astro.responseSent");
 class App {
+  /**
+   * The current environment of the application
+   */
   #env;
   #manifest;
   #manifestData;
@@ -4220,7 +4265,6 @@ class App {
     dest: consoleLogDestination,
     level: "info"
   };
-  #base;
   #baseWithoutTrailingSlash;
   constructor(manifest, streaming = true) {
     this.#manifest = manifest;
@@ -4228,26 +4272,39 @@ class App {
       routes: manifest.routes.map((route) => route.routeData)
     };
     this.#routeDataToRouteInfo = new Map(manifest.routes.map((route) => [route.routeData, route]));
-    this.#env = createEnvironment({
-      adapterName: manifest.adapterName,
+    this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#manifest.base);
+    this.#env = this.#createEnvironment(streaming);
+  }
+  set setManifest(newManifest) {
+    this.#manifest = newManifest;
+  }
+  /**
+   * Creates an environment by reading the stored manifest
+   *
+   * @param streaming
+   * @private
+   */
+  #createEnvironment(streaming = false) {
+    return createEnvironment({
+      adapterName: this.#manifest.adapterName,
       logging: this.#logging,
-      markdown: manifest.markdown,
+      markdown: this.#manifest.markdown,
       mode: "production",
-      compressHTML: manifest.compressHTML,
-      renderers: manifest.renderers,
-      clientDirectives: manifest.clientDirectives,
-      async resolve(specifier) {
-        if (!(specifier in manifest.entryModules)) {
+      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}]`);
         }
-        const bundlePath = manifest.entryModules[specifier];
+        const bundlePath = this.#manifest.entryModules[specifier];
         switch (true) {
           case bundlePath.startsWith("data:"):
           case bundlePath.length === 0: {
             return bundlePath;
           }
           default: {
-            return createAssetLink(bundlePath, manifest.base, manifest.assetsPrefix);
+            return createAssetLink(bundlePath, this.#manifest.base, this.#manifest.assetsPrefix);
           }
         }
       },
@@ -4256,11 +4313,12 @@ class App {
       ssr: true,
       streaming
     });
-    this.#base = this.#manifest.base || "/";
-    this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#base);
+  }
+  set setManifestData(newManifestData) {
+    this.#manifestData = newManifestData;
   }
   removeBase(pathname) {
-    if (pathname.startsWith(this.#base)) {
+    if (pathname.startsWith(this.#manifest.base)) {
       return pathname.slice(this.#baseWithoutTrailingSlash.length + 1);
     }
     return pathname;
@@ -4305,34 +4363,140 @@ class App {
       defaultStatus = 404;
     }
     let mod = await this.#getModuleForRoute(routeData);
-    if (routeData.type === "page" || routeData.type === "redirect") {
-      let response = await this.#renderPage(request, routeData, mod, defaultStatus);
+    const pageModule = await mod.page();
+    const url = new URL(request.url);
+    const renderContext = await this.#createRenderContext(
+      url,
+      request,
+      routeData,
+      mod,
+      defaultStatus
+    );
+    let response;
+    try {
+      response = await tryRenderRoute(
+        routeData.type,
+        renderContext,
+        this.#env,
+        pageModule,
+        mod.onRequest
+      );
+    } catch (err) {
+      error(this.#logging, "ssr", err.stack || err.message || String(err));
+      response = new Response(null, {
+        status: 500,
+        statusText: "Internal server error"
+      });
+    }
+    if (isResponse(response, routeData.type)) {
       if (response.status === 500 || response.status === 404) {
         const errorRouteData = matchRoute("/" + response.status, this.#manifestData);
         if (errorRouteData && errorRouteData.route !== routeData.route) {
           mod = await this.#getModuleForRoute(errorRouteData);
           try {
-            let errorResponse = await this.#renderPage(
+            const newRenderContext = await this.#createRenderContext(
+              url,
               request,
-              errorRouteData,
+              routeData,
               mod,
               response.status
             );
+            const page = await mod.page();
+            const errorResponse = await tryRenderRoute(
+              routeData.type,
+              newRenderContext,
+              this.#env,
+              page
+            );
             return errorResponse;
           } catch {
           }
         }
       }
+      Reflect.set(response, responseSentSymbol, true);
       return response;
-    } else if (routeData.type === "endpoint") {
-      return this.#callEndpoint(request, routeData, mod, defaultStatus);
     } else {
-      throw new Error(`Unsupported route type [${routeData.type}].`);
+      if (response.type === "response") {
+        if (response.response.headers.get("X-Astro-Response") === "Not-Found") {
+          const fourOhFourRequest = new Request(new URL("/404", request.url));
+          const fourOhFourRouteData = this.match(fourOhFourRequest);
+          if (fourOhFourRouteData) {
+            return this.render(fourOhFourRequest, fourOhFourRouteData);
+          }
+        }
+        return response.response;
+      } else {
+        const body = response.body;
+        const headers = new Headers();
+        const mimeType = mime.getType(url.pathname);
+        if (mimeType) {
+          headers.set("Content-Type", `${mimeType};charset=utf-8`);
+        } else {
+          headers.set("Content-Type", "text/plain;charset=utf-8");
+        }
+        const bytes = this.#encoder.encode(body);
+        headers.set("Content-Length", bytes.byteLength.toString());
+        const newResponse = new Response(bytes, {
+          status: 200,
+          headers
+        });
+        attachToResponse(newResponse, response.cookies);
+        return newResponse;
+      }
     }
   }
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }
+  /**
+   * 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.#env,
+        mod: handler
+      });
+    } else {
+      const pathname = prependForwardSlash(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.#env
+      });
+    }
+  }
   async #getModuleForRoute(route) {
     if (route.type === "redirect") {
       return RedirectSinglePageBuiltModule;
@@ -4356,121 +4520,6 @@ class App {
       }
     }
   }
-  async #renderPage(request, routeData, page, status = 200) {
-    const url = new URL(request.url);
-    const pathname = prependForwardSlash(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));
-      }
-    }
-    try {
-      const mod = await page.page();
-      const renderContext = await createRenderContext({
-        request,
-        pathname,
-        componentMetadata: this.#manifest.componentMetadata,
-        scripts,
-        styles,
-        links,
-        route: routeData,
-        status,
-        mod,
-        env: this.#env
-      });
-      const apiContext = createAPIContext({
-        request: renderContext.request,
-        params: renderContext.params,
-        props: renderContext.props,
-        site: this.#env.site,
-        adapterName: this.#env.adapterName
-      });
-      let response;
-      if (page.onRequest) {
-        response = await callMiddleware(
-          this.#env.logging,
-          page.onRequest,
-          apiContext,
-          () => {
-            return renderPage({
-              mod,
-              renderContext,
-              env: this.#env,
-              cookies: apiContext.cookies
-            });
-          }
-        );
-      } else {
-        response = await renderPage({
-          mod,
-          renderContext,
-          env: this.#env,
-          cookies: apiContext.cookies
-        });
-      }
-      Reflect.set(request, responseSentSymbol, true);
-      return response;
-    } catch (err) {
-      error(this.#logging, "ssr", err.stack || err.message || String(err));
-      return new Response(null, {
-        status: 500,
-        statusText: "Internal server error"
-      });
-    }
-  }
-  async #callEndpoint(request, routeData, page, status = 200) {
-    const url = new URL(request.url);
-    const pathname = "/" + this.removeBase(url.pathname);
-    const mod = await page.page();
-    const handler = mod;
-    const ctx = await createRenderContext({
-      request,
-      pathname,
-      route: routeData,
-      status,
-      env: this.#env,
-      mod: handler
-    });
-    const result = await callEndpoint(handler, this.#env, ctx, page.onRequest);
-    if (result.type === "response") {
-      if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
-        const fourOhFourRequest = new Request(new URL("/404", request.url));
-        const fourOhFourRouteData = this.match(fourOhFourRequest);
-        if (fourOhFourRouteData) {
-          return this.render(fourOhFourRequest, fourOhFourRouteData);
-        }
-      }
-      return result.response;
-    } else {
-      const body = result.body;
-      const headers = new Headers();
-      const mimeType = mime.getType(url.pathname);
-      if (mimeType) {
-        headers.set("Content-Type", `${mimeType};charset=utf-8`);
-      } else {
-        headers.set("Content-Type", "text/plain;charset=utf-8");
-      }
-      const bytes = this.#encoder.encode(body);
-      headers.set("Content-Length", bytes.byteLength.toString());
-      const response = new Response(bytes, {
-        status: 200,
-        headers
-      });
-      attachToResponse(response, result.cookies);
-      return response;
-    }
-  }
 }
 
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
@@ -4540,4 +4589,4 @@ class NodeApp extends App {
   }
 }
 
-export { Fragment as F, NodeApp as N, createComponent as a, addAttribute as b, createAstro as c, renderComponent as d, renderSlot as e, renderHead as f, deserializeManifest as g, server_default as h, maybeRenderHead as m, renderTemplate as r, spreadAttributes as s, unescapeHTML as u };
+export { Fragment as F, NodeApp as N, createComponent as a, renderComponent as b, createAstro as c, addAttribute as d, renderSlot as e, renderHead as f, deserializeManifest as g, server_default as h, maybeRenderHead as m, renderTemplate as r, spreadAttributes as s, unescapeHTML as u };