cloudcommerce 2.0.7 → 2.0.9

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

@@ -1,20 +1,20 @@
 import fs from 'node:fs';
-import http from 'node:http';
-import { TLSSocket } from 'node:tls';
 import { appendForwardSlash as appendForwardSlash$1, joinPaths, trimSlashes, slash, prependForwardSlash, removeTrailingForwardSlash, collapseDuplicateSlashes } from '@astrojs/internal-helpers/path';
 import { serialize, parse } from 'cookie';
-import { l as levels, g as getEventPrefix, L as Logger, A as AstroIntegrationLogger, manifest } from './manifest_oV2meNKS.mjs';
+import { A as AstroError, R as ResponseSentError, o as MiddlewareNoDataOrNextCalled, p as MiddlewareNotAResponse, G as GetStaticPathsRequired, q as InvalidGetStaticPathsReturn, t as InvalidGetStaticPathsEntry, v as GetStaticPathsExpectedParams, w as GetStaticPathsInvalidRouteParam, P as PageNumberParamNotFound, N as NoMatchingStaticPathFound, x as PrerenderDynamicEndpointPathCollide, y as LocalsNotAnObject, z as ASTRO_VERSION, C as ClientAddressNotAvailable, S as StaticClientAddressNotAvailable, B as renderEndpoint, D as ReservedSlotName, k as renderSlotToString, H as renderJSX, J as chunkToString, K as CantRenderPage, O as renderPage$1 } from './chunks/astro_tggR3S_9.mjs';
+import { l as levels, g as getEventPrefix, L as Logger, A as AstroIntegrationLogger, manifest } from './manifest_RrmXPEuL.mjs';
 import 'kleur/colors';
-import { A as AstroError, R as ResponseSentError, o as MiddlewareNoDataOrNextCalled, p as MiddlewareNotAResponse, G as GetStaticPathsRequired, q as InvalidGetStaticPathsReturn, t as InvalidGetStaticPathsEntry, v as GetStaticPathsExpectedParams, w as GetStaticPathsInvalidRouteParam, P as PageNumberParamNotFound, N as NoMatchingStaticPathFound, x as PrerenderDynamicEndpointPathCollide, y as LocalsNotAnObject, z as ASTRO_VERSION, C as ClientAddressNotAvailable, S as StaticClientAddressNotAvailable, B as renderEndpoint, D as ReservedSlotName, k as renderSlotToString, H as renderJSX, J as chunkToString, K as CantRenderPage, O as renderPage$1 } from './chunks/astro_H-6uiAAG.mjs';
 import 'clsx';
 import buffer from 'node:buffer';
 import crypto from 'node:crypto';
-import https from 'https';
+import http from 'node:http';
+import https$1 from 'https';
+import enableDestroy from 'server-destroy';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import os from 'os';
+import url from 'node:url';
 import send from 'send';
-import enableDestroy from 'server-destroy';
+import os from 'node:os';
+import https from 'node:https';
 import { renderers } from './renderers.mjs';
 
 function getPathByLocale(locale, locales) {
@@ -84,25 +84,41 @@ function createI18nMiddleware(i18n, base, trailingSlash) {
     const response = await next();
     if (response instanceof Response) {
       const pathnameContainsDefaultLocale = url.pathname.includes(`/${defaultLocale}`);
-      if (i18n.routing === "prefix-other-locales" && pathnameContainsDefaultLocale) {
-        const newLocation = url.pathname.replace(`/${defaultLocale}`, "");
-        response.headers.set("Location", newLocation);
-        return new Response(null, {
-          status: 404,
-          headers: response.headers
-        });
-      } else if (i18n.routing === "prefix-always") {
-        if (url.pathname === base + "/" || url.pathname === base) {
-          if (trailingSlash === "always") {
-            return context.redirect(`${appendForwardSlash$1(joinPaths(base, i18n.defaultLocale))}`);
-          } else {
-            return context.redirect(`${joinPaths(base, i18n.defaultLocale)}`);
+      switch (i18n.routing) {
+        case "pathname-prefix-other-locales": {
+          if (pathnameContainsDefaultLocale) {
+            const newLocation = url.pathname.replace(`/${defaultLocale}`, "");
+            response.headers.set("Location", newLocation);
+            return new Response(null, {
+              status: 404,
+              headers: response.headers
+            });
+          }
+          break;
+        }
+        case "pathname-prefix-always-no-redirect": {
+          const isRoot = url.pathname === base + "/" || url.pathname === base;
+          if (!(isRoot || pathnameHasLocale(url.pathname, i18n.locales))) {
+            return new Response(null, {
+              status: 404,
+              headers: response.headers
+            });
+          }
+          break;
+        }
+        case "pathname-prefix-always": {
+          if (url.pathname === base + "/" || url.pathname === base) {
+            if (trailingSlash === "always") {
+              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
+            });
           }
-        } else if (!pathnameHasLocale(url.pathname, i18n.locales)) {
-          return new Response(null, {
-            status: 404,
-            headers: response.headers
-          });
         }
       }
       if (response.status >= 300 && fallback) {
@@ -124,7 +140,7 @@ function createI18nMiddleware(i18n, base, trailingSlash) {
           const fallbackLocale = fallback[urlLocale];
           const pathFallbackLocale = getPathByLocale(fallbackLocale, locales);
           let newPathname;
-          if (pathFallbackLocale === defaultLocale && routing === "prefix-other-locales") {
+          if (pathFallbackLocale === defaultLocale && routing === "pathname-prefix-other-locales") {
             newPathname = url.pathname.replace(`/${urlLocale}`, ``);
           } else {
             newPathname = url.pathname.replace(`/${urlLocale}`, `/${pathFallbackLocale}`);
@@ -168,10 +184,12 @@ class AstroCookies {
   #request;
   #requestValues;
   #outgoing;
+  #consumed;
   constructor(request) {
     this.#request = request;
     this.#requestValues = null;
     this.#outgoing = null;
+    this.#consumed = false;
   }
   /**
    * Astro.cookies.delete(key) is used to delete a cookie. Using this method will result
@@ -241,6 +259,13 @@ class AstroCookies {
    * @param options Options for the cookie, such as the path and security settings.
    */
   set(key, value, options) {
+    if (this.#consumed) {
+      const warning = new Error(
+        "Astro.cookies.set() was called after the cookies had already been sent to the browser.\nThis may have happened if this method was called in an imported component.\nPlease make sure that Astro.cookies.set() is only called in the frontmatter of the main page."
+      );
+      warning.name = "Warning";
+      console.warn(warning);
+    }
     let serializedValue;
     if (typeof value === "string") {
       serializedValue = value;
@@ -280,6 +305,14 @@ class AstroCookies {
       yield value[1];
     }
   }
+  /**
+   * Behaves the same as AstroCookies.prototype.headers(),
+   * but allows a warning when cookies are set after the instance is consumed.
+   */
+  static consume(cookies) {
+    cookies.#consumed = true;
+    return cookies.headers();
+  }
   #ensureParsed(options = void 0) {
     if (!this.#requestValues) {
       this.#parse(options);
@@ -324,7 +357,7 @@ function* getSetCookiesFromResponse(response) {
   if (!cookies) {
     return [];
   }
-  for (const headerValue of cookies.headers()) {
+  for (const headerValue of AstroCookies.consume(cookies)) {
     yield headerValue;
   }
   return [];
@@ -410,8 +443,8 @@ function redirectRouteGenerate(redirectRoute, data) {
 }
 function redirectRouteStatus(redirectRoute, method = "GET") {
   const routeData = redirectRoute.redirectRoute;
-  if (typeof routeData?.redirect === "object") {
-    return routeData.redirect.status;
+  if (routeData && typeof redirectRoute.redirect === "object") {
+    return redirectRoute.redirect.status;
   } else if (method !== "GET") {
     return 308;
   }
@@ -714,7 +747,7 @@ function validatePrerenderEndpointCollision(route, mod, params) {
   }
 }
 
-const clientLocalsSymbol$2 = Symbol.for("astro.locals");
+const clientLocalsSymbol$1 = Symbol.for("astro.locals");
 async function createRenderContext(options) {
   const request = options.request;
   const pathname = options.pathname ?? new URL(request.url).pathname;
@@ -738,13 +771,13 @@ async function createRenderContext(options) {
   Object.defineProperty(context, "locals", {
     enumerable: true,
     get() {
-      return Reflect.get(request, clientLocalsSymbol$2);
+      return Reflect.get(request, clientLocalsSymbol$1);
     },
     set(val) {
       if (typeof val !== "object") {
         throw new AstroError(LocalsNotAnObject);
       } else {
-        Reflect.set(request, clientLocalsSymbol$2, val);
+        Reflect.set(request, clientLocalsSymbol$1, val);
       }
     }
   });
@@ -875,7 +908,7 @@ function computeCurrentLocale(request, locales, routingStrategy, defaultLocale)
       }
     }
   }
-  if (routingStrategy === "prefix-other-locales") {
+  if (routingStrategy === "pathname-prefix-other-locales") {
     return defaultLocale;
   }
   return void 0;
@@ -885,8 +918,8 @@ function createEnvironment(options) {
   return options;
 }
 
-const clientAddressSymbol$2 = Symbol.for("astro.clientAddress");
-const clientLocalsSymbol$1 = Symbol.for("astro.locals");
+const clientAddressSymbol$3 = Symbol.for("astro.clientAddress");
+const clientLocalsSymbol = Symbol.for("astro.locals");
 function createAPIContext({
   request,
   params,
@@ -946,8 +979,8 @@ function createAPIContext({
     },
     url: new URL(request.url),
     get clientAddress() {
-      if (clientAddressSymbol$2 in request) {
-        return Reflect.get(request, clientAddressSymbol$2);
+      if (clientAddressSymbol$3 in request) {
+        return Reflect.get(request, clientAddressSymbol$3);
       }
       if (adapterName) {
         throw new AstroError({
@@ -959,10 +992,10 @@ function createAPIContext({
       }
     },
     get locals() {
-      let locals = Reflect.get(request, clientLocalsSymbol$1);
+      let locals = Reflect.get(request, clientLocalsSymbol);
       if (locals === void 0) {
         locals = {};
-        Reflect.set(request, clientLocalsSymbol$1, locals);
+        Reflect.set(request, clientLocalsSymbol, locals);
       }
       if (typeof locals !== "object") {
         throw new AstroError(LocalsNotAnObject);
@@ -974,7 +1007,7 @@ function createAPIContext({
       if (typeof val !== "object") {
         throw new AstroError(LocalsNotAnObject);
       } else {
-        Reflect.set(request, clientLocalsSymbol$1, val);
+        Reflect.set(request, clientLocalsSymbol, val);
       }
     }
   };
@@ -1089,7 +1122,7 @@ function matchRoute(pathname, manifest) {
   });
 }
 
-const clientAddressSymbol$1 = Symbol.for("astro.clientAddress");
+const clientAddressSymbol$2 = Symbol.for("astro.clientAddress");
 const responseSentSymbol$1 = Symbol.for("astro.responseSent");
 function getFunctionExpression(slot) {
   if (!slot)
@@ -1195,7 +1228,7 @@ function createResult(args) {
         // @ts-expect-error
         __proto__: astroGlobal,
         get clientAddress() {
-          if (!(clientAddressSymbol$1 in request)) {
+          if (!(clientAddressSymbol$2 in request)) {
             if (args.adapterName) {
               throw new AstroError({
                 ...ClientAddressNotAvailable,
@@ -1205,7 +1238,7 @@ function createResult(args) {
               throw new AstroError(StaticClientAddressNotAvailable);
             }
           }
-          return Reflect.get(request, clientAddressSymbol$1);
+          return Reflect.get(request, clientAddressSymbol$2);
         },
         get cookies() {
           if (cookies) {
@@ -1496,9 +1529,10 @@ class SSRRoutePipeline extends Pipeline {
   }
 }
 
-const clientLocalsSymbol = Symbol.for("astro.locals");
+const localsSymbol = Symbol.for("astro.locals");
+const clientAddressSymbol$1 = Symbol.for("astro.clientAddress");
 const responseSentSymbol = Symbol.for("astro.responseSent");
-const STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
+const REROUTABLE_STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
 class App {
   /**
    * The current environment of the application
@@ -1592,7 +1626,15 @@ class App {
   async render(request, routeDataOrOptions, maybeLocals) {
     let routeData;
     let locals;
-    if (routeDataOrOptions && ("routeData" in routeDataOrOptions || "locals" in routeDataOrOptions)) {
+    let clientAddress;
+    let addCookieHeader;
+    if (routeDataOrOptions && ("addCookieHeader" in routeDataOrOptions || "clientAddress" in routeDataOrOptions || "locals" in routeDataOrOptions || "routeData" in routeDataOrOptions)) {
+      if ("addCookieHeader" in routeDataOrOptions) {
+        addCookieHeader = routeDataOrOptions.addCookieHeader;
+      }
+      if ("clientAddress" in routeDataOrOptions) {
+        clientAddress = routeDataOrOptions.clientAddress;
+      }
       if ("routeData" in routeDataOrOptions) {
         routeData = routeDataOrOptions.routeData;
       }
@@ -1606,6 +1648,12 @@ class App {
         this.#logRenderOptionsDeprecationWarning();
       }
     }
+    if (locals) {
+      Reflect.set(request, localsSymbol, locals);
+    }
+    if (clientAddress) {
+      Reflect.set(request, clientAddressSymbol$1, clientAddress);
+    }
     if (request.url !== collapseDuplicateSlashes(request.url)) {
       request = new Request(collapseDuplicateSlashes(request.url), request);
     }
@@ -1615,7 +1663,6 @@ class App {
     if (!routeData) {
       return this.#renderError(request, { status: 404 });
     }
-    Reflect.set(request, clientLocalsSymbol, locals ?? {});
     const pathname = this.#getPathnameFromRequest(request);
     const defaultStatus = this.#getDefaultStatusCode(routeData, pathname);
     const mod = await this.#getModuleForRoute(routeData);
@@ -1630,7 +1677,7 @@ class App {
     );
     let response;
     try {
-      let i18nMiddleware = createI18nMiddleware(
+      const i18nMiddleware = createI18nMiddleware(
         this.#manifest.i18n,
         this.#manifest.base,
         this.#manifest.trailingSlash
@@ -1657,15 +1704,19 @@ class App {
       }
     }
     if (routeData.type === "page" || routeData.type === "redirect") {
-      if (STATUS_CODES.has(response.status)) {
+      if (REROUTABLE_STATUS_CODES.has(response.status)) {
         return this.#renderError(request, {
           response,
           status: response.status
         });
       }
-      Reflect.set(response, responseSentSymbol, true);
-      return response;
     }
+    if (addCookieHeader) {
+      for (const setCookieHeaderValue of App.getSetCookieFromResponse(response)) {
+        response.headers.append("set-cookie", setCookieHeaderValue);
+      }
+    }
+    Reflect.set(response, responseSentSymbol, true);
     return response;
   }
   #logRenderOptionsDeprecationWarning() {
@@ -1680,6 +1731,18 @@ class App {
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }
+  /**
+   * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
+   * For example,
+   * ```ts
+   * for (const cookie_ of App.getSetCookieFromResponse(response)) {
+   *     const cookie: string = cookie_
+   * }
+   * ```
+   * @param response The response to read cookies from.
+   * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
+   */
+  static getSetCookieFromResponse = getSetCookiesFromResponse;
   /**
    * Creates the render context of the current route
    */
@@ -1856,6 +1919,23 @@ class App {
   }
 }
 
+const createOutgoingHttpHeaders = (headers) => {
+  if (!headers) {
+    return void 0;
+  }
+  const nodeHeaders = Object.fromEntries(headers.entries());
+  if (Object.keys(nodeHeaders).length === 0) {
+    return void 0;
+  }
+  if (headers.has("set-cookie")) {
+    const cookieHeaders = headers.getSetCookie();
+    if (cookieHeaders.length > 1) {
+      nodeHeaders["set-cookie"] = cookieHeaders;
+    }
+  }
+  return nodeHeaders;
+};
+
 function apply() {
   if (!globalThis.crypto) {
     Object.defineProperty(globalThis, "crypto", {
@@ -1870,26 +1950,92 @@ function apply() {
 }
 
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
-function createRequestFromNodeRequest(req, options) {
-  const protocol = req.socket instanceof TLSSocket || req.headers["x-forwarded-proto"] === "https" ? "https" : "http";
-  const hostname = req.headers.host || req.headers[":authority"];
-  const url = `${protocol}://${hostname}${req.url}`;
-  const headers = makeRequestHeaders(req);
-  const method = req.method || "GET";
-  let bodyProps = {};
-  const bodyAllowed = method !== "HEAD" && method !== "GET" && !options?.emptyBody;
-  if (bodyAllowed) {
-    bodyProps = makeRequestBody(req);
-  }
-  const request = new Request(url, {
-    method,
-    headers,
-    ...bodyProps
-  });
-  if (req.socket?.remoteAddress) {
-    Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+class NodeApp extends App {
+  match(req) {
+    if (!(req instanceof Request)) {
+      req = NodeApp.createRequest(req, {
+        skipBody: true
+      });
+    }
+    return super.match(req);
+  }
+  render(req, routeDataOrOptions, maybeLocals) {
+    if (!(req instanceof Request)) {
+      req = NodeApp.createRequest(req);
+    }
+    return super.render(req, routeDataOrOptions, maybeLocals);
+  }
+  /**
+   * Converts a NodeJS IncomingMessage into a web standard Request.
+   * ```js
+   * import { NodeApp } from 'astro/app/node';
+   * import { createServer } from 'node:http';
+   *
+   * const server = createServer(async (req, res) => {
+   *     const request = NodeApp.createRequest(req);
+   *     const response = await app.render(request);
+   *     await NodeApp.writeResponse(response, res);
+   * })
+   * ```
+   */
+  static createRequest(req, { skipBody = false } = {}) {
+    const protocol = req.headers["x-forwarded-proto"] ?? ("encrypted" in req.socket && req.socket.encrypted ? "https" : "http");
+    const hostname = req.headers.host || req.headers[":authority"];
+    const url = `${protocol}://${hostname}${req.url}`;
+    const options = {
+      method: req.method || "GET",
+      headers: makeRequestHeaders(req)
+    };
+    const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
+    if (bodyAllowed) {
+      Object.assign(options, makeRequestBody(req));
+    }
+    const request = new Request(url, options);
+    if (req.socket?.remoteAddress) {
+      Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+    }
+    return request;
+  }
+  /**
+   * Streams a web-standard Response into a NodeJS Server Response.
+   * ```js
+   * import { NodeApp } from 'astro/app/node';
+   * import { createServer } from 'node:http';
+   *
+   * const server = createServer(async (req, res) => {
+   *     const request = NodeApp.createRequest(req);
+   *     const response = await app.render(request);
+   *     await NodeApp.writeResponse(response, res);
+   * })
+   * ```
+   * @param source WhatWG Response
+   * @param destination NodeJS ServerResponse
+   */
+  static async writeResponse(source, destination) {
+    const { status, headers, body } = source;
+    destination.writeHead(status, createOutgoingHttpHeaders(headers));
+    if (body) {
+      try {
+        const reader = body.getReader();
+        destination.on("close", () => {
+          reader.cancel().catch((err) => {
+            console.error(
+              `There was an uncaught error in the middle of the stream while rendering ${destination.req.url}.`,
+              err
+            );
+          });
+        });
+        let result = await reader.read();
+        while (!result.done) {
+          destination.write(result.value);
+          result = await reader.read();
+        }
+      } catch {
+        destination.write("Internal server error");
+      }
+    }
+    destination.end();
   }
-  return request;
 }
 function makeRequestHeaders(req) {
   const headers = new Headers();
@@ -1930,132 +2076,117 @@ function asyncIterableToBodyProps(iterable) {
     // The duplex property is required when using a ReadableStream or async
     // iterable for the body. The type definitions do not include the duplex
     // property because they are not up-to-date.
-    // @ts-expect-error
     duplex: "half"
   };
 }
-class NodeApp extends App {
-  match(req) {
-    if (!(req instanceof Request)) {
-      req = createRequestFromNodeRequest(req, {
-        emptyBody: true
+
+function createAppHandler(app) {
+  return async (req, res, next, locals) => {
+    const request = NodeApp.createRequest(req);
+    const routeData = app.match(request);
+    if (routeData) {
+      const response = await app.render(request, {
+        addCookieHeader: true,
+        locals,
+        routeData
       });
+      await NodeApp.writeResponse(response, res);
+    } else if (next) {
+      return next();
+    } else {
+      const response = await app.render(req);
+      await NodeApp.writeResponse(response, res);
     }
-    return super.match(req);
-  }
-  render(req, routeDataOrOptions, maybeLocals) {
-    if (!(req instanceof Request)) {
-      req = createRequestFromNodeRequest(req);
-    }
-    return super.render(req, routeDataOrOptions, maybeLocals);
-  }
+  };
 }
 
-const createOutgoingHttpHeaders = (headers) => {
-  if (!headers) {
-    return void 0;
-  }
-  const nodeHeaders = Object.fromEntries(headers.entries());
-  if (Object.keys(nodeHeaders).length === 0) {
-    return void 0;
-  }
-  if (headers.has("set-cookie")) {
-    const cookieHeaders = headers.getSetCookie();
-    if (cookieHeaders.length > 1) {
-      nodeHeaders["set-cookie"] = cookieHeaders;
-    }
-  }
-  return nodeHeaders;
-};
-
-function nodeMiddleware_default(app, mode) {
-  return async function(...args) {
-    let error = null;
-    let locals;
-    let [req, res, next] = args;
-    if (mode === "middleware") {
-      let { [3]: _locals } = args;
-      locals = _locals;
-    }
-    if (args[0] instanceof Error) {
-      [error, req, res, next] = args;
-      if (mode === "middleware") {
-        let { [4]: _locals } = args;
-        locals = _locals;
-      }
-      if (error) {
-        if (next) {
-          return next(error);
-        } else {
-          throw error;
+function createStaticHandler(app, options) {
+  const client = resolveClientDir(options);
+  return (req, res, ssr) => {
+    if (req.url) {
+      let pathname = app.removeBase(req.url);
+      pathname = decodeURI(new URL(pathname, "http://host").pathname);
+      const stream = send(req, pathname, {
+        root: client,
+        dotfiles: pathname.startsWith("/.well-known/") ? "allow" : "deny"
+      });
+      let forwardError = false;
+      stream.on("error", (err) => {
+        if (forwardError) {
+          console.error(err.toString());
+          res.writeHead(500);
+          res.end("Internal server error");
+          return;
         }
-      }
-    }
-    const logger = app.getAdapterLogger();
-    try {
-      const routeData = app.match(req);
-      if (routeData) {
-        try {
-          const response = await app.render(req, { routeData, locals });
-          await writeWebResponse(app, res, response, logger);
-        } catch (err) {
-          if (next) {
-            next(err);
-          } else {
-            throw err;
-          }
+        ssr();
+      });
+      stream.on("headers", (_res) => {
+        if (pathname.startsWith(`/${options.assets}/`)) {
+          _res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
         }
-      } else if (next) {
-        return next();
-      } else {
-        const response = await app.render(req);
-        await writeWebResponse(app, res, response, logger);
-      }
-    } catch (err) {
-      logger.error(`Could not render ${req.url}`);
-      console.error(err);
-      if (!res.headersSent) {
-        res.writeHead(500, `Server error`);
-        res.end();
-      }
+      });
+      stream.on("directory", () => {
+        let location;
+        if (req.url.includes("?")) {
+          const [url1 = "", search] = req.url.split("?");
+          location = `${url1}/?${search}`;
+        } else {
+          location = appendForwardSlash(req.url);
+        }
+        res.statusCode = 301;
+        res.setHeader("Location", location);
+        res.end(location);
+      });
+      stream.on("file", () => {
+        forwardError = true;
+      });
+      stream.pipe(res);
+    } else {
+      ssr();
     }
   };
 }
-async function writeWebResponse(app, res, webResponse, logger) {
-  const { status, headers, body } = webResponse;
-  if (app.setCookieHeaders) {
-    const setCookieHeaders = Array.from(app.setCookieHeaders(webResponse));
-    if (setCookieHeaders.length) {
-      for (const setCookieHeader of setCookieHeaders) {
-        headers.append("set-cookie", setCookieHeader);
-      }
-    }
+function resolveClientDir(options) {
+  const clientURLRaw = new URL(options.client);
+  const serverURLRaw = new URL(options.server);
+  const rel = path.relative(url.fileURLToPath(serverURLRaw), url.fileURLToPath(clientURLRaw));
+  const serverEntryURL = new URL(import.meta.url);
+  const clientURL = new URL(appendForwardSlash(rel), serverEntryURL);
+  const client = url.fileURLToPath(clientURL);
+  return client;
+}
+function appendForwardSlash(pth) {
+  return pth.endsWith("/") ? pth : pth + "/";
+}
+
+async function logListeningOn(logger, server, options) {
+  await new Promise((resolve) => server.once("listening", resolve));
+  const protocol = server instanceof https.Server ? "https" : "http";
+  const host = getResolvedHostForHttpServer(
+    process.env.HOST !== void 0 && process.env.HOST !== "" ? process.env.HOST : options.host
+  );
+  const { port } = server.address();
+  const address = getNetworkAddress(protocol, host, port);
+  if (host === void 0) {
+    logger.info(
+      `Server listening on 
+  local: ${address.local[0]} 	
+  network: ${address.network[0]}
+`
+    );
+  } else {
+    logger.info(`Server listening on ${address.local[0]}`);
   }
-  const nodeHeaders = createOutgoingHttpHeaders(headers);
-  res.writeHead(status, nodeHeaders);
-  if (body) {
-    try {
-      const reader = body.getReader();
-      res.on("close", () => {
-        reader.cancel().catch((err) => {
-          logger.error(
-            `There was an uncaught error in the middle of the stream while rendering ${res.req.url}.`
-          );
-          console.error(err);
-        });
-      });
-      let result = await reader.read();
-      while (!result.done) {
-        res.write(result.value);
-        result = await reader.read();
-      }
-    } catch {
-      res.write("Internal server error");
-    }
+}
+function getResolvedHostForHttpServer(host) {
+  if (host === false) {
+    return "localhost";
+  } else if (host === true) {
+    return void 0;
+  } else {
+    return host;
   }
-  res.end();
 }
-
 const wildcardHosts = /* @__PURE__ */ new Set(["0.0.0.0", "::", "0000:0000:0000:0000:0000:0000:0000:0000"]);
 function getNetworkAddress(protocol = "http", hostname, port, base) {
   const NetworkAddress = {
@@ -2083,71 +2214,39 @@ function getNetworkAddress(protocol = "http", hostname, port, base) {
   return NetworkAddress;
 }
 
-function parsePathname(pathname, host, port) {
-  try {
-    const urlPathname = new URL(pathname, `http://${host}:${port}`).pathname;
-    return decodeURI(encodeURI(urlPathname));
-  } catch (err) {
-    return void 0;
+function standalone(app, options) {
+  const port = process.env.PORT ? Number(process.env.PORT) : options.port ?? 8080;
+  const hostOptions = typeof options.host === "boolean" ? "localhost" : options.host;
+  const host = process.env.HOST ?? hostOptions;
+  const handler = createStandaloneHandler(app, options);
+  const server = createServer(handler, host, port);
+  server.server.listen(port, host);
+  if (process.env.ASTRO_NODE_LOGGING !== "disabled") {
+    logListeningOn(app.getAdapterLogger(), server.server, options);
   }
+  return {
+    server,
+    done: server.closed()
+  };
 }
-function createServer({ client, port, host, removeBase, assets }, handler) {
-  const assetsPrefix = `/${assets}/`;
-  function isImmutableAsset(pathname) {
-    return pathname.startsWith(assetsPrefix);
-  }
-  const listener = (req, res) => {
-    if (req.url) {
-      let pathname = removeBase(req.url);
-      pathname = pathname[0] === "/" ? pathname : "/" + pathname;
-      const encodedURI = parsePathname(pathname, host, port);
-      if (!encodedURI) {
-        res.writeHead(400);
-        res.end("Bad request.");
-        return res;
-      }
-      const stream = send(req, encodedURI, {
-        root: fileURLToPath(client),
-        dotfiles: pathname.startsWith("/.well-known/") ? "allow" : "deny"
-      });
-      let forwardError = false;
-      stream.on("error", (err) => {
-        if (forwardError) {
-          console.error(err.toString());
-          res.writeHead(500);
-          res.end("Internal server error");
-          return;
-        }
-        handler(req, res);
-      });
-      stream.on("headers", (_res) => {
-        if (isImmutableAsset(encodedURI)) {
-          _res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
-        }
-      });
-      stream.on("directory", () => {
-        let location;
-        if (req.url.includes("?")) {
-          const [url = "", search] = req.url.split("?");
-          location = `${url}/?${search}`;
-        } else {
-          location = req.url + "/";
-        }
-        res.statusCode = 301;
-        res.setHeader("Location", location);
-        res.end(location);
-      });
-      stream.on("file", () => {
-        forwardError = true;
-      });
-      stream.pipe(res);
-    } else {
-      handler(req, res);
+function createStandaloneHandler(app, options) {
+  const appHandler = createAppHandler(app);
+  const staticHandler = createStaticHandler(app, options);
+  return (req, res) => {
+    try {
+      decodeURI(req.url);
+    } catch {
+      res.writeHead(400);
+      res.end("Bad request.");
+      return;
     }
+    staticHandler(req, res, () => appHandler(req, res));
   };
+}
+function createServer(listener, host, port) {
   let httpServer;
   if (process.env.SERVER_CERT_PATH && process.env.SERVER_KEY_PATH) {
-    httpServer = https.createServer(
+    httpServer = https$1.createServer(
       {
         key: fs.readFileSync(process.env.SERVER_KEY_PATH),
         cert: fs.readFileSync(process.env.SERVER_CERT_PATH)
@@ -2157,82 +2256,52 @@ function createServer({ client, port, host, removeBase, assets }, handler) {
   } else {
     httpServer = http.createServer(listener);
   }
-  httpServer.listen(port, host);
   enableDestroy(httpServer);
   const closed = new Promise((resolve, reject) => {
     httpServer.addListener("close", resolve);
     httpServer.addListener("error", reject);
   });
-  return {
+  const previewable = {
     host,
     port,
     closed() {
       return closed;
     },
-    server: httpServer,
-    stop: async () => {
+    async stop() {
       await new Promise((resolve, reject) => {
         httpServer.destroy((err) => err ? reject(err) : resolve(void 0));
       });
     }
   };
-}
-
-function resolvePaths(options) {
-  const clientURLRaw = new URL(options.client);
-  const serverURLRaw = new URL(options.server);
-  const rel = path.relative(fileURLToPath(serverURLRaw), fileURLToPath(clientURLRaw));
-  const serverEntryURL = new URL(import.meta.url);
-  const clientURL = new URL(appendForwardSlash(rel), serverEntryURL);
   return {
-    client: clientURL
+    server: httpServer,
+    ...previewable
   };
 }
-function appendForwardSlash(pth) {
-  return pth.endsWith("/") ? pth : pth + "/";
-}
-function getResolvedHostForHttpServer(host) {
-  if (host === false) {
-    return "127.0.0.1";
-  } else if (host === true) {
-    return void 0;
-  } else {
-    return host;
-  }
-}
-function startServer$1(app, options) {
+
+function createMiddleware(app) {
+  const handler = createAppHandler(app);
   const logger = app.getAdapterLogger();
-  const port = process.env.PORT ? Number(process.env.PORT) : options.port ?? 8080;
-  const { client } = resolvePaths(options);
-  const handler = nodeMiddleware_default(app, options.mode);
-  const host = getResolvedHostForHttpServer(
-    process.env.HOST !== void 0 && process.env.HOST !== "" ? process.env.HOST : options.host
-  );
-  const server = createServer(
-    {
-      client,
-      port,
-      host,
-      removeBase: app.removeBase.bind(app),
-      assets: options.assets
-    },
-    handler
-  );
-  const protocol = server.server instanceof https.Server ? "https" : "http";
-  const address = getNetworkAddress(protocol, host, port);
-  if (host === void 0) {
-    logger.info(
-      `Server listening on 
-  local: ${address.local[0]} 	
-  network: ${address.network[0]}
-`
-    );
-  } else {
-    logger.info(`Server listening on ${address.local[0]}`);
-  }
-  return {
-    server,
-    done: server.closed()
+  return async function(...args) {
+    const [req, res, next, locals] = args;
+    if (req instanceof Error) {
+      const error = req;
+      if (next) {
+        return next(error);
+      } else {
+        throw error;
+      }
+    }
+    try {
+      await handler(req, res, next, locals);
+    } catch (err) {
+      logger.error(`Could not render ${req.url}`);
+      console.error(err);
+      if (!res.headersSent) {
+        res.writeHead(500, `Server error`);
+        res.end();
+      }
+    }
   };
 }
 
@@ -2241,8 +2310,8 @@ function createExports(manifest, options) {
   const app = new NodeApp(manifest);
   return {
     options,
-    handler: nodeMiddleware_default(app, options.mode),
-    startServer: () => startServer$1(app, options)
+    handler: options.mode === "middleware" ? createMiddleware(app) : createStandaloneHandler(app, options),
+    startServer: () => standalone(app, options)
   };
 }
 function start(manifest, options) {
@@ -2250,7 +2319,7 @@ function start(manifest, options) {
     return;
   }
   const app = new NodeApp(manifest);
-  startServer$1(app, options);
+  standalone(app, options);
 }
 
 const adapter = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
@@ -2259,12 +2328,12 @@ const adapter = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   start
 }, Symbol.toStringTag, { value: 'Module' }));
 
-const _page0  = () => import('./chunks/node_-eQO2yOn.mjs');
-const _page1  = () => import('./chunks/~fallback_M-xiy2GE.mjs');
-const _page2  = () => import('./chunks/_page__WXDIwV7g.mjs');
-const _page3  = () => import('./chunks/index_eXlHIU83.mjs');
-const _page4  = () => import('./chunks/account_DOT2RzND.mjs');
-const _page5  = () => import('./chunks/_.._D6rq0cLa.mjs');const pageMap = new Map([["../../node_modules/.pnpm/astro@4.1.1_@types+node@18.19.5_typescript@5.2.2/node_modules/astro/dist/assets/endpoint/node.js", _page0],["src/pages/~fallback.astro", _page1],["src/pages/blog/[page].astro", _page2],["src/pages/app/index.astro", _page3],["src/pages/app/account.astro", _page4],["src/pages/[...slug].astro", _page5]]);
+const _page0  = () => import('./chunks/node_kUJIRL0c.mjs');
+const _page1  = () => import('./chunks/index_e3ytAL8v.mjs');
+const _page2  = () => import('./chunks/account_jmelxnlw.mjs');
+const _page3  = () => import('./chunks/_page__lWVlZyRe.mjs');
+const _page4  = () => import('./chunks/~fallback_EZqiEAFE.mjs');
+const _page5  = () => import('./chunks/_.._h5R83hoK.mjs');const pageMap = new Map([["../../node_modules/.pnpm/astro@4.2.1_@types+node@18.19.7_typescript@5.2.2/node_modules/astro/dist/assets/endpoint/node.js", _page0],["src/pages/app/index.astro", _page1],["src/pages/app/account.astro", _page2],["src/pages/blog/[page].astro", _page3],["src/pages/~fallback.astro", _page4],["src/pages/[...slug].astro", _page5]]);
 const _manifest = Object.assign(manifest, {
 	pageMap,
 	renderers,