vue-ssr-lite 0.2.11 → 0.2.12

package/dist/chunks/SsrServerRuntime-BbWemkgs.mjs

@@ -0,0 +1,716 @@
+import { createServer as ce } from "node:http";
+import { stat as J, readFile as te } from "node:fs/promises";
+import { resolve as z, sep as X, extname as re } from "node:path";
+import { s as le, q as W, u as de, t as ue, i as he, p as me, l as fe, g as pe } from "./SsrHtmlRuntime-BJUxjM2F.mjs";
+import { c as ge, j as ye, r as we } from "./SsrApplicationRuntime-CKjoPpvD.mjs";
+import { renderToString as ve } from "@vue/server-renderer";
+import { c as Se } from "./SsrDiagnosticsRuntime-B5VbSgsA.mjs";
+import { c as oe } from "./SsrSerialization-DeKozeIm.mjs";
+const N = () => globalThis.performance?.now?.() ?? Date.now(), Q = (e) => new TextEncoder().encode(e).byteLength, Y = (e, r, o, s) => {
+  for (const l of s) {
+    const d = { requestId: r, applicationId: o, code: l.code };
+    e?.warn ? e.warn(`ssr.diagnostic.${l.code}`, d) : console.warn(`[vue-ssr-lite] ${l.message}`, d);
+  }
+}, be = async (e, r, o = {}) => {
+  const s = N(), l = Math.max(1, Math.floor(o.maxResolutionPasses ?? 4)), d = o.resolutionDeadlineMs ?? 0, v = o.diagnostics ?? process.env.NODE_ENV !== "production", x = ye(!0);
+  let M = s, p = s, g = s, C, i, y = "", t = "", n = 0, w;
+  const a = async () => {
+    if (!i) return;
+    const h = i;
+    i = void 0;
+    try {
+      await e.cleanup?.(h.context);
+    } catch (b) {
+      console.error("[vue-ssr-lite] application cleanup failed", b);
+    }
+    try {
+      h.hydration.dispose();
+    } catch (b) {
+      console.error("[vue-ssr-lite] hydration cleanup failed", b);
+    }
+  };
+  try {
+    let h = !1;
+    for (let S = 0; S < l && !h; S += 1) {
+      if (n = S + 1, x.beginPass(S), i = await ge(e, {
+        server: !0,
+        request: r,
+        resumeState: S === 0 ? void 0 : C,
+        resolution: x
+      }), S === 0 && (M = N()), i.router) {
+        const u = new URL(r.url);
+        await i.router.push(`${u.pathname}${u.search}${u.hash}`), await i.router.isReady(), i.router.currentRoute.value.matched.length === 0 && (i.context.response.statusCode = 404);
+      }
+      S === 0 && (p = N());
+      const T = {};
+      y = await ve(i.app, T), t = T.teleports?.body ?? "", g = N();
+      const R = x.pendingWork(), A = x.additionalPassRequested(), $ = S === l - 1;
+      if (R.length === 0 && !A || $) {
+        h = !0, $ && (R.length > 0 || A) && Y(o.logger, r.requestId, e.id, [
+          {
+            code: "resolution-pass-limit",
+            message: `Resolution did not settle within ${l} render passes; serializing the last render.`
+          }
+        ]);
+        break;
+      }
+      await x.drain(d, r.signal), C = i.hydration.collect(), await a();
+    }
+    if (!i) throw new Error("SSR render produced no application instance.");
+    const b = await e.resolveHead?.(i.context) ?? i.context.head.value;
+    v && Y(
+      o.logger,
+      r.requestId,
+      e.id,
+      Se({
+        html: y,
+        route: i.router?.currentRoute.value ?? null,
+        requestUrl: r.url,
+        applicationId: e.id
+      })
+    );
+    const D = {
+      version: 1,
+      applicationId: e.id,
+      publicConfig: r.publicConfig,
+      domain: r.domain,
+      application: i.context.state,
+      plugins: i.hydration.collect()
+    }, f = Q(oe(D)), c = N();
+    return {
+      html: y,
+      teleports: t,
+      head: b,
+      response: i.context.response,
+      hydrationState: D,
+      metrics: {
+        requestId: r.requestId,
+        applicationId: e.id,
+        contextDurationMs: M - s,
+        routeDurationMs: p - M,
+        renderDurationMs: g - p,
+        totalDurationMs: c - s,
+        htmlBytes: Q(y),
+        stateBytes: f,
+        renderPasses: n
+      }
+    };
+  } catch (h) {
+    throw w = h, h;
+  } finally {
+    let h;
+    if (i) {
+      try {
+        await e.cleanup?.(i.context);
+      } catch (b) {
+        h = b, console.error("[vue-ssr-lite] application cleanup failed", b);
+      }
+      try {
+        i.hydration.dispose();
+      } catch (b) {
+        console.error("[vue-ssr-lite] hydration cleanup failed", b), h || (h = b);
+      }
+    }
+    if (x.dispose(), !w && h) throw h;
+  }
+}, xe = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".xml": "application/xml; charset=utf-8"
+}, Re = async (e, r, o) => {
+  try {
+    const s = decodeURIComponent(r).replace(/^\/+/, "");
+    if (!s || o.includes(s)) return null;
+    const l = z(e, s), d = e.endsWith(X) ? e : `${e}${X}`;
+    return !l.startsWith(d) || !(await J(l)).isFile() ? null : {
+      statusCode: 200,
+      body: await te(l),
+      headers: {
+        "content-type": xe[re(l)] || "application/octet-stream",
+        "cache-control": r.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "public, max-age=3600"
+      }
+    };
+  } catch {
+    return null;
+  }
+}, Ee = (e) => typeof e == "string" ? new TextEncoder().encode(e).byteLength : e?.byteLength ?? 0, Z = (e) => ({
+  statusCode: e.statusCode,
+  body: e.body instanceof Uint8Array ? e.body.slice() : e.body,
+  headers: e.headers ? { ...e.headers } : void 0
+}), _e = (e = {}) => {
+  const r = Number(e.maxEntries ?? 500), o = Number(e.maxBytes ?? 32 * 1024 * 1024), s = Number.isFinite(r) ? Math.max(1, Math.floor(r)) : 500, l = Number.isFinite(o) ? Math.max(1, Math.floor(o)) : 32 * 1024 * 1024, d = /* @__PURE__ */ new Map();
+  let v = 0;
+  const x = (p) => {
+    const g = d.get(p);
+    return g ? (d.delete(p), v -= g.size, !0) : !1;
+  }, M = () => {
+    const p = Date.now();
+    for (const [g, C] of d)
+      C.expiresAt <= p && x(g);
+    for (; d.size > s || v > l; ) {
+      const g = d.keys().next().value;
+      if (!g) break;
+      x(g);
+    }
+  };
+  return {
+    get(p) {
+      const g = d.get(p);
+      return g ? g.expiresAt <= Date.now() ? (x(p), null) : (d.delete(p), d.set(p, g), Z(g.response)) : null;
+    },
+    set(p, g, C) {
+      const i = Number(C.ttlMs);
+      if (!Number.isFinite(i) || i <= 0) return;
+      x(p);
+      const y = Z(g), t = Ee(y.body);
+      t > l || (d.set(p, {
+        response: y,
+        expiresAt: Date.now() + i,
+        size: t,
+        tags: new Set(C.tags ?? [])
+      }), v += t, M());
+    },
+    invalidate(p = {}) {
+      const g = new Set(p.keys ?? []), C = new Set(p.tags ?? []);
+      let i = 0;
+      for (const [y, t] of d)
+        (!g.size && !C.size || g.has(y) || [...C].some((w) => t.tags.has(w))) && x(y) && (i += 1);
+      return i;
+    }
+  };
+}, Ce = async (e, r, o) => {
+  if (!o || r.method !== "GET" || r.cookie || !Number.isFinite(o.ttlMs) || o.ttlMs <= 0)
+    return null;
+  const s = o.vary ? await o.vary(r) : "";
+  return s == null ? null : JSON.stringify([
+    "vue-ssr-lite:v1",
+    e,
+    r.host,
+    r.pathname,
+    r.search,
+    s
+  ]);
+}, Pe = (e, r, o) => {
+  const s = Object.entries(e.headers ?? {}), l = String(
+    s.find(([v]) => v.toLowerCase() === "cache-control")?.[1] || ""
+  ).toLowerCase();
+  return e.statusCode === 200 && typeof e.body == "string" && !s.some(([v]) => v.toLowerCase() === "set-cookie") && !l.includes("private") && !l.includes("no-store") && (o.shouldCache?.(e, r) ?? !0);
+};
+class se extends Error {
+  constructor() {
+    super("SSR request timed out."), this.name = "SsrRequestTimeoutError";
+  }
+}
+const Me = (e) => {
+  const r = e ?? 4173;
+  if (!Number.isInteger(r) || r < 0 || r > 65535)
+    throw new Error("SSR server port must be an integer between 0 and 65535.");
+  return r;
+}, Ie = (e) => e === "0.0.0.0" || e === "::" || e === "::1" ? "localhost" : e, De = (e, r, o) => {
+  const s = `http://${Ie(e)}:${r}/`;
+  console.log(
+    [
+      "",
+      "✓  Server Ready",
+      "",
+      `  ➜ Local:  ${s}`,
+      `  ➜ Role:   ${o}`,
+      ""
+    ].join(`
+`)
+  );
+}, q = async (e, r) => {
+  const o = await pe(e, {
+    development: !r.production,
+    root: r.root,
+    importModule: r.vite ? async (s) => await r.vite.ssrLoadModule(s) : void 0
+  });
+  for (const s of o.applications) {
+    const l = !s.roles?.length || !o.server.role || s.roles.includes(o.server.role);
+    if (s.kind === "ssr" && l && !s.application)
+      throw new Error(
+        `SSR application "${s.id}" requires an ssr application definition.`
+      );
+  }
+  return o;
+}, $e = (e, r, o, s) => {
+  const d = `<script type="application/json" id="vue-ssr-lite-domain">${oe({
+    version: 1,
+    applicationId: r,
+    domain: o,
+    publicConfig: s
+  })}<\/script>`;
+  return e.includes("</body>") ? e.replace(/<\/body>/i, `	${d}
+</body>`) : `${e}
+${d}`;
+}, F = {
+  "referrer-policy": "strict-origin-when-cross-origin",
+  "x-content-type-options": "nosniff",
+  "x-frame-options": "SAMEORIGIN"
+}, U = (e, r) => {
+  if (e.method !== "GET" && e.method !== "HEAD") return !1;
+  if (e.headers["sec-fetch-mode"] === "navigate") return !0;
+  const o = String(e.headers.accept || "");
+  return o.includes("text/html") ? !0 : (!o || o === "*/*") && !re(r);
+}, ke = (e, r, o = "") => r.end(e.method === "HEAD" ? "" : o), I = (e, r, o) => {
+  r.writeHead(o.statusCode, o.headers ?? {}), ke(e, r, o.body ?? "");
+}, j = (e, r, o, s) => I(e, r, {
+  statusCode: o,
+  body: JSON.stringify(s),
+  headers: {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  }
+}), ee = async (e, r, o) => {
+  if (!Number.isFinite(r) || r <= 0) return e;
+  let s;
+  const l = new Promise((d, v) => {
+    s = setTimeout(() => {
+      o.abort(), v(new se());
+    }, r);
+  });
+  try {
+    return await Promise.race([e, l]);
+  } finally {
+    s && clearTimeout(s);
+  }
+}, Te = (e) => e.headers, Ae = (e, r, o) => new Promise((s, l) => {
+  e.middlewares(r, o, (d) => {
+    d ? l(d) : s();
+  });
+}), Be = async (e) => {
+  let r = !1;
+  const o = await q(await e.loadRuntime(), e), s = o.server, l = s.host || "0.0.0.0", d = Me(s.port), v = z(
+    s.root || e.root,
+    s.clientOutDir || "dist/client"
+  );
+  let x = o, M = null;
+  const p = () => e.production ? Promise.resolve(o) : M || (M = (async () => {
+    try {
+      const t = await q(await e.loadRuntime(), e);
+      return x = t, t;
+    } catch (t) {
+      return s.logger?.error?.("ssr.runtime.reload.failed", {
+        error: t instanceof Error ? t.message : "Unknown error"
+      }), x;
+    } finally {
+      M = null;
+    }
+  })(), M), g = async (t, n, w) => {
+    const a = t.server.root || e.root, h = await te(
+      z(e.production ? v : a, n),
+      "utf8"
+    );
+    if (e.production || !e.vite) return h;
+    const b = `/${n.replaceAll("\\", "/").replace(/^\/+/, "")}`;
+    return e.vite.transformIndexHtml(b, h, w);
+  }, C = async (t) => {
+    const n = t.server.root || e.root, w = t.applications.filter(
+      (a) => !a.roles?.length || !t.server.role || a.roles.includes(t.server.role)
+    );
+    await Promise.all(
+      w.map(async (a) => {
+        if (!(await J(
+          z(
+            e.production ? v : n,
+            a.template
+          )
+        )).isFile())
+          throw new Error(`SSR client entry is missing: ${a.template}`);
+      })
+    ), await Promise.all((t.readiness ?? []).map((a) => a.run()));
+  }, i = o.applications.filter(
+    (t) => !t.roles?.length || !o.server.role || t.roles.includes(o.server.role)
+  );
+  await Promise.all(
+    i.map(async (t) => {
+      const n = o.server.root || e.root;
+      if (!(await J(
+        z(
+          e.production ? v : n,
+          t.template
+        )
+      )).isFile())
+        throw new Error(`Missing client entry: ${t.template}`);
+    })
+  );
+  const y = ce(async (t, n) => {
+    const w = Date.now();
+    let a = "/", h = "unknown", b;
+    const D = new AbortController();
+    t.once("aborted", () => D.abort()), n.once("close", () => {
+      n.writableEnded || D.abort();
+    });
+    try {
+      const f = await p(), c = f.server, S = new URL(t.url || "/", "http://internal");
+      a = S.pathname;
+      const T = c.healthPath || "/healthz", R = c.readinessPath || "/readyz";
+      if (a === T)
+        return j(t, n, 200, {
+          status: "ok",
+          service: f.name,
+          role: c.role || "default",
+          timestamp: new Date(w).toISOString()
+        });
+      if (a === R) {
+        if (r)
+          return j(t, n, 503, {
+            status: "error",
+            service: f.name,
+            message: "Server is shutting down."
+          });
+        try {
+          return await C(f), j(t, n, 200, {
+            status: "ok",
+            service: f.name,
+            role: c.role || "default"
+          });
+        } catch {
+          return j(t, n, 503, {
+            status: "error",
+            service: f.name,
+            message: "A required dependency is unavailable."
+          });
+        }
+      }
+      const A = le(
+        t.headers["x-forwarded-host"],
+        t.headers.host,
+        c.trustProxy
+      );
+      if (!A)
+        return I(t, n, {
+          statusCode: 400,
+          body: U(t, a) ? W("Invalid request", "The Host header is invalid.") : JSON.stringify({ status: "error", message: "Invalid Host header." }),
+          headers: {
+            "content-type": U(t, a) ? "text/html; charset=utf-8" : "application/json; charset=utf-8",
+            "cache-control": "no-store",
+            ...F
+          }
+        });
+      const $ = de(
+        f.applications,
+        A,
+        f.defaultApplicationId
+      );
+      if (!$)
+        return j(t, n, 421, {
+          status: "error",
+          service: f.name,
+          message: "No application serves this host."
+        });
+      const u = $.entry;
+      if (h = u.id, c.logger?.debug?.("ssr.host_resolved", {
+        entryId: u.id,
+        category: $.category,
+        specificity: $.specificity,
+        matchedPattern: $.matchedPattern,
+        hostname: $.normalizedHostname,
+        role: c.role || "default"
+      }), u.roles?.length && c.role && !u.roles.includes(c.role)) {
+        const m = `Runtime role does not serve application "${u.id}".`;
+        return I(t, n, {
+          statusCode: 421,
+          body: U(t, a) ? W("Misdirected request", m) : JSON.stringify({ status: "error", message: m }),
+          headers: {
+            "content-type": U(t, a) ? "text/html; charset=utf-8" : "application/json; charset=utf-8",
+            "cache-control": "no-store",
+            ...F
+          }
+        });
+      }
+      const G = ue(
+        t.headers["x-forwarded-proto"],
+        t.socket.encrypted ? "https" : "http",
+        c.trustProxy
+      ), K = we(
+        A,
+        u,
+        f.development
+      ), ne = he(
+        t.headers.cookie,
+        u.cookieAllowlist,
+        u.cookieDenylist
+      ), P = {
+        requestId: String(t.headers["x-request-id"] || "").trim() || `${w.toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
+        url: new URL(
+          `${S.pathname}${S.search}`,
+          `${G}://${A}`
+        ).href,
+        host: A,
+        protocol: G,
+        method: t.method || "GET",
+        headers: Te(t),
+        cookie: ne,
+        publicConfig: u.publicConfig,
+        domain: K,
+        signal: D.signal,
+        pathname: a,
+        search: S.search,
+        entryId: u.id
+      };
+      b = P;
+      const ae = {
+        signal: D.signal,
+        logger: c.logger
+      };
+      for (const m of u.endpoints) {
+        if (!m.match(P)) continue;
+        const k = await ee(
+          Promise.resolve(m.handle(P, ae)),
+          c.requestTimeoutMs ?? 15e3,
+          D
+        );
+        if (k) return I(t, n, k);
+      }
+      if (e.production) {
+        const m = await Re(
+          v,
+          a,
+          f.applications.map(({ template: k }) => k)
+        );
+        if (m) return I(t, n, m);
+      } else if (e.vite && (a.startsWith("/src/") || a.startsWith("/@") || a.includes(".") || a === "/__vite_ping") && (await Ae(e.vite, t, n), n.writableEnded))
+        return;
+      if (!U(t, a))
+        return j(t, n, 404, {
+          status: "error",
+          service: f.name,
+          message: "Resource not found."
+        });
+      const H = u.kind === "ssr" ? u.responseCache : void 0;
+      let L = null;
+      try {
+        L = await Ce(
+          u.id,
+          P,
+          H
+        );
+      } catch (m) {
+        c.logger?.warn?.("ssr.cache.key.failed", {
+          entryId: u.id,
+          requestId: P.requestId,
+          error: m instanceof Error ? m.message : "Unknown cache error"
+        });
+      }
+      if (H && L)
+        try {
+          const m = await H.store.get(L);
+          if (m)
+            return I(t, n, {
+              ...m,
+              headers: {
+                ...m.headers,
+                "server-timing": 'cache;desc="hit"'
+              }
+            });
+        } catch (m) {
+          c.logger?.warn?.("ssr.cache.read.failed", {
+            entryId: u.id,
+            requestId: P.requestId,
+            error: m instanceof Error ? m.message : "Unknown cache error"
+          });
+        }
+      let O = await g(f, u.template, t.url || "/");
+      if (u.kind === "spa")
+        return I(t, n, {
+          statusCode: 200,
+          body: $e(
+            O,
+            u.id,
+            K,
+            u.publicConfig
+          ),
+          headers: {
+            "content-type": "text/html; charset=utf-8",
+            "cache-control": u.cacheControl || "private, no-store",
+            vary: "Host, X-Forwarded-Host",
+            ...F
+          }
+        });
+      const _ = u.application;
+      O = me(
+        O,
+        u.mountSelector || _.mountSelector || "#app"
+      );
+      const V = c.requestTimeoutMs ?? 15e3, E = await ee(
+        be(_, P, {
+          maxResolutionPasses: c.maxResolutionPasses,
+          resolutionDeadlineMs: c.resolutionDeadlineMs ?? V,
+          diagnostics: c.diagnostics ?? !e.production,
+          logger: c.logger
+        }),
+        V,
+        D
+      );
+      if (E.response.redirect) {
+        const m = E.response.redirect, k = new URL(m.location, P.url);
+        if (k.protocol !== "http:" && k.protocol !== "https:")
+          throw new Error("SSR redirects must use HTTP or HTTPS.");
+        if (!m.allowExternal && k.origin !== new URL(P.url).origin)
+          throw new Error("Cross-origin redirect requires allowExternal: true.");
+        return I(t, n, {
+          statusCode: m.statusCode ?? 302,
+          headers: {
+            location: k.href,
+            "cache-control": "no-store"
+          }
+        });
+      }
+      const ie = fe(O, {
+        applicationId: _.id,
+        html: E.html,
+        teleports: E.teleports,
+        head: E.head,
+        state: E.hydrationState
+      });
+      c.onMetrics?.(E.metrics), c.logger?.info?.("ssr.render.complete", E.metrics);
+      const B = {
+        statusCode: E.response.statusCode,
+        body: ie,
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": u.cacheControl || "private, no-store",
+          vary: "Host, X-Forwarded-Host",
+          "server-timing": [
+            `context;dur=${E.metrics.contextDurationMs.toFixed(1)}`,
+            `route;dur=${E.metrics.routeDurationMs.toFixed(1)}`,
+            `render;dur=${E.metrics.renderDurationMs.toFixed(1)}`
+          ].join(", "),
+          ...E.response.headers,
+          ...F
+        }
+      };
+      if (H && L && Pe(B, P, H))
+        try {
+          await H.store.set(L, B, {
+            ttlMs: H.ttlMs,
+            tags: await H.tags?.(P)
+          });
+        } catch (m) {
+          c.logger?.warn?.("ssr.cache.write.failed", {
+            entryId: u.id,
+            requestId: P.requestId,
+            error: m instanceof Error ? m.message : "Unknown cache error"
+          });
+        }
+      return I(t, n, B);
+    } catch (f) {
+      e.vite?.ssrFixStacktrace(f);
+      const c = await p().catch(() => o);
+      if (c.server.logger?.error?.("ssr.request.failed", {
+        entryId: h,
+        pathname: a,
+        error: f instanceof Error ? f.message : "Unknown error"
+      }), n.writableEnded) return;
+      if (n.headersSent) return n.destroy();
+      const S = f instanceof se, T = S ? 504 : 500;
+      if (c.server.renderError)
+        try {
+          const R = await c.server.renderError({
+            error: f,
+            kind: S ? "timeout" : "internal",
+            production: e.production,
+            request: b,
+            entryId: h === "unknown" ? void 0 : h
+          });
+          if (R)
+            return I(t, n, {
+              ...R,
+              statusCode: R.statusCode >= 400 ? R.statusCode : T,
+              headers: {
+                ...R.headers,
+                "cache-control": "no-store",
+                ...F
+              }
+            });
+        } catch (R) {
+          c.server.logger?.error?.("ssr.error-renderer.failed", {
+            entryId: h,
+            error: R instanceof Error ? R.message : "Unknown error renderer failure"
+          });
+        }
+      return U(t, a) ? I(t, n, {
+        statusCode: T,
+        body: W(
+          S ? "Request timed out" : "Application unavailable",
+          e.production ? "The application could not render this page. Please try again." : f instanceof Error ? f.message : "Unknown rendering failure."
+        ),
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": "no-store",
+          ...F
+        }
+      }) : j(t, n, T, {
+        status: "error",
+        service: c.name
+      });
+    }
+  });
+  return {
+    nodeServer: y,
+    address: () => {
+      const t = y.address();
+      return {
+        host: typeof t == "object" && t ? t.address : l,
+        port: typeof t == "object" && t ? t.port : d
+      };
+    },
+    listen: () => new Promise((t, n) => {
+      const w = (a) => n(a);
+      y.once("error", w), y.listen(d, l, () => {
+        y.off("error", w), De(
+          l,
+          d,
+          s.role || "default"
+        ), t();
+      });
+    }),
+    close: async () => {
+      if (r) return;
+      r = !0;
+      const t = s.shutdownTimeoutMs ?? 1e4;
+      let n;
+      try {
+        await Promise.race([
+          Promise.all([
+            new Promise((w, a) => {
+              y.close(
+                (h) => h ? a(h) : w()
+              );
+            }),
+            e.vite?.close()
+          ]),
+          new Promise((w, a) => {
+            n = setTimeout(() => {
+              y.closeAllConnections?.(), a(new Error("SSR server graceful shutdown timed out."));
+            }, t);
+          })
+        ]);
+      } finally {
+        n && clearTimeout(n);
+      }
+    }
+  };
+};
+export {
+  _e as a,
+  Re as b,
+  Be as c,
+  Ce as d,
+  Pe as i,
+  be as r
+};