@nuxt/nitro-server-nightly 0.0.0 → 4.2.0-29344151.f836eca0

package/dist/runtime/handlers/error.d.ts

@@ -0,0 +1,3 @@
+import type { NitroErrorHandler } from 'nitropack/types';
+declare const _default: NitroErrorHandler;
+export default _default;

package/dist/runtime/handlers/error.js

@@ -0,0 +1,63 @@
+import { joinURL, withQuery, withoutBase } from "ufo";
+import { appendResponseHeader, getRequestHeaders, send, setResponseHeader, setResponseHeaders, setResponseStatus } from "h3";
+import { useNitroApp, useRuntimeConfig } from "nitropack/runtime";
+import { isJsonRequest } from "../utils/error.js";
+import { generateErrorOverlayHTML } from "../utils/dev.js";
+export default (async function errorhandler(error, event, { defaultHandler }) {
+  if (event.handled || isJsonRequest(event)) {
+    return;
+  }
+  const defaultRes = await defaultHandler(error, event, { json: true });
+  const statusCode = error.statusCode || 500;
+  if (statusCode === 404 && defaultRes.status === 302) {
+    setResponseHeaders(event, defaultRes.headers);
+    setResponseStatus(event, defaultRes.status, defaultRes.statusText);
+    return send(event, JSON.stringify(defaultRes.body, null, 2));
+  }
+  if (import.meta.dev && typeof defaultRes.body !== "string" && Array.isArray(defaultRes.body.stack)) {
+    defaultRes.body.stack = defaultRes.body.stack.join("\n");
+  }
+  const errorObject = defaultRes.body;
+  const url = new URL(errorObject.url);
+  errorObject.url = withoutBase(url.pathname, useRuntimeConfig(event).app.baseURL) + url.search + url.hash;
+  errorObject.message ||= "Server Error";
+  errorObject.data ||= error.data;
+  errorObject.statusMessage ||= error.statusMessage;
+  delete defaultRes.headers["content-type"];
+  delete defaultRes.headers["content-security-policy"];
+  setResponseHeaders(event, defaultRes.headers);
+  const reqHeaders = getRequestHeaders(event);
+  const isRenderingError = event.path.startsWith("/__nuxt_error") || !!reqHeaders["x-nuxt-error"];
+  const res = isRenderingError ? null : await useNitroApp().localFetch(
+    withQuery(joinURL(useRuntimeConfig(event).app.baseURL, "/__nuxt_error"), errorObject),
+    {
+      headers: { ...reqHeaders, "x-nuxt-error": "true" },
+      redirect: "manual"
+    }
+  ).catch(() => null);
+  if (event.handled) {
+    return;
+  }
+  if (!res) {
+    const { template } = await import("../templates/error-500.js");
+    if (import.meta.dev) {
+      errorObject.description = errorObject.message;
+    }
+    setResponseHeader(event, "Content-Type", "text/html;charset=UTF-8");
+    return send(event, template(errorObject));
+  }
+  const html = await res.text();
+  for (const [header, value] of res.headers.entries()) {
+    if (header === "set-cookie") {
+      appendResponseHeader(event, header, value);
+      continue;
+    }
+    setResponseHeader(event, header, value);
+  }
+  setResponseStatus(event, res.status && res.status !== 200 ? res.status : defaultRes.status, res.statusText || defaultRes.statusText);
+  if (import.meta.dev) {
+    const prettyResponse = await defaultHandler(error, event, { json: false });
+    return send(event, html.replace("</body>", `${generateErrorOverlayHTML(prettyResponse.body)}</body>`));
+  }
+  return send(event, html);
+});

package/dist/runtime/handlers/island.d.ts

@@ -0,0 +1,4 @@
+import type { RenderResponse } from 'nitropack/types';
+import type { NuxtIslandResponse } from 'nuxt/app';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<NuxtIslandResponse | Partial<RenderResponse>>>;
+export default _default;

package/dist/runtime/handlers/island.js

@@ -0,0 +1,100 @@
+import { useNitroApp } from "nitropack/runtime";
+import { destr } from "destr";
+import { defineEventHandler, getQuery, readBody, setResponseHeaders } from "h3";
+import { resolveUnrefHeadInput } from "@unhead/vue";
+import { getRequestDependencies } from "vue-bundle-renderer/runtime";
+import { getQuery as getURLQuery } from "ufo";
+import { islandCache, islandPropCache } from "../utils/cache.js";
+import { createSSRContext } from "../utils/renderer/app.js";
+import { getSSRRenderer } from "../utils/renderer/build-files.js";
+import { renderInlineStyles } from "../utils/renderer/inline-styles.js";
+import { getClientIslandResponse, getServerComponentHTML, getSlotIslandResponse } from "../utils/renderer/islands.js";
+const ISLAND_SUFFIX_RE = /\.json(?:\?.*)?$/;
+export default defineEventHandler(async (event) => {
+  const nitroApp = useNitroApp();
+  setResponseHeaders(event, {
+    "content-type": "application/json;charset=utf-8",
+    "x-powered-by": "Nuxt"
+  });
+  if (import.meta.prerender && event.path && await islandCache.hasItem(event.path)) {
+    return islandCache.getItem(event.path);
+  }
+  const islandContext = await getIslandContext(event);
+  const ssrContext = {
+    ...createSSRContext(event),
+    islandContext,
+    noSSR: false,
+    url: islandContext.url
+  };
+  const renderer = await getSSRRenderer();
+  const renderResult = await renderer.renderToString(ssrContext).catch(async (err) => {
+    await ssrContext.nuxt?.hooks.callHook("app:error", err);
+    throw err;
+  });
+  if (ssrContext.payload?.error) {
+    throw ssrContext.payload.error;
+  }
+  const inlinedStyles = await renderInlineStyles(ssrContext.modules ?? []);
+  await ssrContext.nuxt?.hooks.callHook("app:rendered", { ssrContext, renderResult });
+  if (inlinedStyles.length) {
+    ssrContext.head.push({ style: inlinedStyles });
+  }
+  if (import.meta.dev) {
+    const { styles } = getRequestDependencies(ssrContext, renderer.rendererContext);
+    const link = [];
+    for (const resource of Object.values(styles)) {
+      if ("inline" in getURLQuery(resource.file)) {
+        continue;
+      }
+      if (resource.file.includes("scoped") && !resource.file.includes("pages/")) {
+        link.push({ rel: "stylesheet", href: renderer.rendererContext.buildAssetsURL(resource.file), crossorigin: "" });
+      }
+    }
+    if (link.length) {
+      ssrContext.head.push({ link }, { mode: "server" });
+    }
+  }
+  const islandHead = {};
+  for (const entry of ssrContext.head.entries.values()) {
+    for (const [key, value] of Object.entries(resolveUnrefHeadInput(entry.input))) {
+      const currentValue = islandHead[key];
+      if (Array.isArray(currentValue)) {
+        currentValue.push(...value);
+      }
+      islandHead[key] = value;
+    }
+  }
+  const islandResponse = {
+    id: islandContext.id,
+    head: islandHead,
+    html: getServerComponentHTML(renderResult.html),
+    components: getClientIslandResponse(ssrContext),
+    slots: getSlotIslandResponse(ssrContext)
+  };
+  await nitroApp.hooks.callHook("render:island", islandResponse, { event, islandContext });
+  if (import.meta.prerender) {
+    await islandCache.setItem(`/__nuxt_island/${islandContext.name}_${islandContext.id}.json`, islandResponse);
+    await islandPropCache.setItem(`/__nuxt_island/${islandContext.name}_${islandContext.id}.json`, event.path);
+  }
+  return islandResponse;
+});
+async function getIslandContext(event) {
+  let url = event.path || "";
+  if (import.meta.prerender && event.path && await islandPropCache.hasItem(event.path)) {
+    url = await islandPropCache.getItem(event.path);
+  }
+  const componentParts = url.substring("/__nuxt_island".length + 1).replace(ISLAND_SUFFIX_RE, "").split("_");
+  const hashId = componentParts.length > 1 ? componentParts.pop() : void 0;
+  const componentName = componentParts.join("_");
+  const context = event.method === "GET" ? getQuery(event) : await readBody(event);
+  const ctx = {
+    url: "/",
+    ...context,
+    id: hashId,
+    name: componentName,
+    props: destr(context.props) || {},
+    slots: {},
+    components: {}
+  };
+  return ctx;
+}

package/dist/runtime/handlers/renderer.d.ts

@@ -0,0 +1,8 @@
+export interface NuxtRenderResponse {
+    body: string;
+    statusCode: number;
+    statusMessage?: string;
+    headers: Record<string, string>;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/handlers/renderer.js

@@ -0,0 +1,237 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import {
+  getPrefetchLinks,
+  getPreloadLinks,
+  getRequestDependencies,
+  renderResourceHeaders
+} from "vue-bundle-renderer/runtime";
+import { appendResponseHeader, createError, getQuery, getResponseStatus, getResponseStatusText, writeEarlyHints } from "h3";
+import { getQuery as getURLQuery, joinURL } from "ufo";
+import { propsToString, renderSSRHead } from "@unhead/vue/server";
+import destr from "destr";
+import { defineRenderHandler, getRouteRules, useNitroApp } from "nitropack/runtime";
+import { getRenderer } from "../utils/renderer/build-files.js";
+import { payloadCache } from "../utils/cache.js";
+import { renderPayloadJsonScript, renderPayloadResponse, renderPayloadScript, splitPayload } from "../utils/renderer/payload.js";
+import { createSSRContext, setSSRError } from "../utils/renderer/app.js";
+import { renderInlineStyles } from "../utils/renderer/inline-styles.js";
+import { replaceIslandTeleports } from "../utils/renderer/islands.js";
+import { renderSSRHeadOptions } from "#internal/unhead.config.mjs";
+import { appHead, appTeleportAttrs, appTeleportTag, componentIslands, appManifest as isAppManifestEnabled } from "#internal/nuxt.config.mjs";
+import entryIds from "#internal/nuxt/entry-ids.mjs";
+import { entryFileName } from "#internal/entry-chunk.mjs";
+import { buildAssetsURL, publicAssetsURL } from "#internal/nuxt/paths";
+import { relative } from "pathe";
+globalThis.__buildAssetsURL = buildAssetsURL;
+globalThis.__publicAssetsURL = publicAssetsURL;
+if (process.env.NUXT_ASYNC_CONTEXT && !("AsyncLocalStorage" in globalThis)) {
+  globalThis.AsyncLocalStorage = AsyncLocalStorage;
+}
+const HAS_APP_TELEPORTS = !!(appTeleportTag && appTeleportAttrs.id);
+const APP_TELEPORT_OPEN_TAG = HAS_APP_TELEPORTS ? `<${appTeleportTag}${propsToString(appTeleportAttrs)}>` : "";
+const APP_TELEPORT_CLOSE_TAG = HAS_APP_TELEPORTS ? `</${appTeleportTag}>` : "";
+const PAYLOAD_URL_RE = process.env.NUXT_JSON_PAYLOADS ? /^[^?]*\/_payload.json(?:\?.*)?$/ : /^[^?]*\/_payload.js(?:\?.*)?$/;
+const PAYLOAD_FILENAME = process.env.NUXT_JSON_PAYLOADS ? "_payload.json" : "_payload.js";
+let entryPath;
+export default defineRenderHandler(async (event) => {
+  const nitroApp = useNitroApp();
+  const ssrError = event.path.startsWith("/__nuxt_error") ? getQuery(event) : null;
+  if (ssrError && !("__unenv__" in event.node.req)) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Page Not Found: /__nuxt_error"
+    });
+  }
+  const ssrContext = createSSRContext(event);
+  const headEntryOptions = { mode: "server" };
+  ssrContext.head.push(appHead, headEntryOptions);
+  if (ssrError) {
+    ssrError.statusCode &&= Number.parseInt(ssrError.statusCode);
+    if (process.env.PARSE_ERROR_DATA && typeof ssrError.data === "string") {
+      try {
+        ssrError.data = destr(ssrError.data);
+      } catch {
+      }
+    }
+    setSSRError(ssrContext, ssrError);
+  }
+  const isRenderingPayload = process.env.NUXT_PAYLOAD_EXTRACTION && PAYLOAD_URL_RE.test(ssrContext.url);
+  if (isRenderingPayload) {
+    const url = ssrContext.url.substring(0, ssrContext.url.lastIndexOf("/")) || "/";
+    ssrContext.url = url;
+    event._path = event.node.req.url = url;
+    if (import.meta.prerender && await payloadCache.hasItem(url)) {
+      return payloadCache.getItem(url);
+    }
+  }
+  const routeOptions = getRouteRules(event);
+  if (routeOptions.ssr === false) {
+    ssrContext.noSSR = true;
+  }
+  const _PAYLOAD_EXTRACTION = import.meta.prerender && process.env.NUXT_PAYLOAD_EXTRACTION && !ssrContext.noSSR;
+  const payloadURL = _PAYLOAD_EXTRACTION ? joinURL(ssrContext.runtimeConfig.app.cdnURL || ssrContext.runtimeConfig.app.baseURL, ssrContext.url.replace(/\?.*$/, ""), PAYLOAD_FILENAME) + "?" + ssrContext.runtimeConfig.app.buildId : void 0;
+  const renderer = await getRenderer(ssrContext);
+  if (process.env.NUXT_EARLY_HINTS && !isRenderingPayload && !import.meta.prerender) {
+    const { link: link2 } = renderResourceHeaders({}, renderer.rendererContext);
+    if (link2) {
+      writeEarlyHints(event, link2);
+    }
+  }
+  if (process.env.NUXT_INLINE_STYLES) {
+    for (const id of entryIds) {
+      ssrContext.modules.add(id);
+    }
+  }
+  const _rendered = await renderer.renderToString(ssrContext).catch(async (error) => {
+    if (ssrContext._renderResponse && error.message === "skipping render") {
+      return {};
+    }
+    const _err = !ssrError && ssrContext.payload?.error || error;
+    await ssrContext.nuxt?.hooks.callHook("app:error", _err);
+    throw _err;
+  });
+  const inlinedStyles = process.env.NUXT_INLINE_STYLES && !ssrContext._renderResponse && !isRenderingPayload ? await renderInlineStyles(ssrContext.modules ?? []) : [];
+  await ssrContext.nuxt?.hooks.callHook("app:rendered", { ssrContext, renderResult: _rendered });
+  if (ssrContext._renderResponse) {
+    return ssrContext._renderResponse;
+  }
+  if (ssrContext.payload?.error && !ssrError) {
+    throw ssrContext.payload.error;
+  }
+  if (isRenderingPayload) {
+    const response = renderPayloadResponse(ssrContext);
+    if (import.meta.prerender) {
+      await payloadCache.setItem(ssrContext.url, response);
+    }
+    return response;
+  }
+  if (_PAYLOAD_EXTRACTION) {
+    appendResponseHeader(event, "x-nitro-prerender", joinURL(ssrContext.url.replace(/\?.*$/, ""), PAYLOAD_FILENAME));
+    await payloadCache.setItem(ssrContext.url === "/" ? "/" : ssrContext.url.replace(/\/$/, ""), renderPayloadResponse(ssrContext));
+  }
+  const NO_SCRIPTS = process.env.NUXT_NO_SCRIPTS || routeOptions.noScripts;
+  const { styles, scripts } = getRequestDependencies(ssrContext, renderer.rendererContext);
+  if (entryFileName && !NO_SCRIPTS) {
+    let path = entryPath;
+    if (!path) {
+      path = buildAssetsURL(entryFileName);
+      if (ssrContext.runtimeConfig.app.cdnURL || /^(?:\/|\.+\/)/.test(path)) {
+        entryPath = path;
+      } else {
+        path = relative(event.path.replace(/\/[^/]+$/, "/"), joinURL("/", path));
+        if (!/^(?:\/|\.+\/)/.test(path)) {
+          path = `./${path}`;
+        }
+      }
+    }
+    ssrContext.head.push({
+      script: [{
+        tagPosition: "head",
+        tagPriority: -2,
+        type: "importmap",
+        innerHTML: JSON.stringify({ imports: { "#entry": path } })
+      }]
+    }, headEntryOptions);
+  }
+  if (_PAYLOAD_EXTRACTION && !NO_SCRIPTS) {
+    ssrContext.head.push({
+      link: [
+        process.env.NUXT_JSON_PAYLOADS ? { rel: "preload", as: "fetch", crossorigin: "anonymous", href: payloadURL } : { rel: "modulepreload", crossorigin: "", href: payloadURL }
+      ]
+    }, headEntryOptions);
+  }
+  if (isAppManifestEnabled && ssrContext._preloadManifest && !NO_SCRIPTS) {
+    ssrContext.head.push({
+      link: [
+        { rel: "preload", as: "fetch", fetchpriority: "low", crossorigin: "anonymous", href: buildAssetsURL(`builds/meta/${ssrContext.runtimeConfig.app.buildId}.json`) }
+      ]
+    }, { ...headEntryOptions, tagPriority: "low" });
+  }
+  if (inlinedStyles.length) {
+    ssrContext.head.push({ style: inlinedStyles });
+  }
+  const link = [];
+  for (const resource of Object.values(styles)) {
+    if (import.meta.dev && "inline" in getURLQuery(resource.file)) {
+      continue;
+    }
+    link.push({ rel: "stylesheet", href: renderer.rendererContext.buildAssetsURL(resource.file), crossorigin: "" });
+  }
+  if (link.length) {
+    ssrContext.head.push({ link }, headEntryOptions);
+  }
+  if (!NO_SCRIPTS) {
+    ssrContext.head.push({
+      link: getPreloadLinks(ssrContext, renderer.rendererContext)
+    }, headEntryOptions);
+    ssrContext.head.push({
+      link: getPrefetchLinks(ssrContext, renderer.rendererContext)
+    }, headEntryOptions);
+    ssrContext.head.push({
+      script: _PAYLOAD_EXTRACTION ? process.env.NUXT_JSON_PAYLOADS ? renderPayloadJsonScript({ ssrContext, data: splitPayload(ssrContext).initial, src: payloadURL }) : renderPayloadScript({ ssrContext, data: splitPayload(ssrContext).initial, src: payloadURL }) : process.env.NUXT_JSON_PAYLOADS ? renderPayloadJsonScript({ ssrContext, data: ssrContext.payload }) : renderPayloadScript({ ssrContext, data: ssrContext.payload })
+    }, {
+      ...headEntryOptions,
+      // this should come before another end of body scripts
+      tagPosition: "bodyClose",
+      tagPriority: "high"
+    });
+  }
+  if (!routeOptions.noScripts) {
+    const tagPosition = _PAYLOAD_EXTRACTION && !process.env.NUXT_JSON_PAYLOADS ? "bodyClose" : "head";
+    ssrContext.head.push({
+      script: Object.values(scripts).map((resource) => ({
+        type: resource.module ? "module" : null,
+        src: renderer.rendererContext.buildAssetsURL(resource.file),
+        defer: resource.module ? null : true,
+        // if we are rendering script tag payloads that import an async payload
+        // we need to ensure this resolves before executing the Nuxt entry
+        tagPosition,
+        crossorigin: ""
+      }))
+    }, headEntryOptions);
+  }
+  const { headTags, bodyTags, bodyTagsOpen, htmlAttrs, bodyAttrs } = await renderSSRHead(ssrContext.head, renderSSRHeadOptions);
+  const htmlContext = {
+    htmlAttrs: htmlAttrs ? [htmlAttrs] : [],
+    head: normalizeChunks([headTags]),
+    bodyAttrs: bodyAttrs ? [bodyAttrs] : [],
+    bodyPrepend: normalizeChunks([bodyTagsOpen, ssrContext.teleports?.body]),
+    body: [
+      componentIslands ? replaceIslandTeleports(ssrContext, _rendered.html) : _rendered.html,
+      APP_TELEPORT_OPEN_TAG + (HAS_APP_TELEPORTS ? joinTags([ssrContext.teleports?.[`#${appTeleportAttrs.id}`]]) : "") + APP_TELEPORT_CLOSE_TAG
+    ],
+    bodyAppend: [bodyTags]
+  };
+  await nitroApp.hooks.callHook("render:html", htmlContext, { event });
+  return {
+    body: renderHTMLDocument(htmlContext),
+    statusCode: getResponseStatus(event),
+    statusMessage: getResponseStatusText(event),
+    headers: {
+      "content-type": "text/html;charset=utf-8",
+      "x-powered-by": "Nuxt"
+    }
+  };
+});
+function normalizeChunks(chunks) {
+  const result = [];
+  for (const _chunk of chunks) {
+    const chunk = _chunk?.trim();
+    if (chunk) {
+      result.push(chunk);
+    }
+  }
+  return result;
+}
+function joinTags(tags) {
+  return tags.join("");
+}
+function joinAttrs(chunks) {
+  if (chunks.length === 0) {
+    return "";
+  }
+  return " " + chunks.join(" ");
+}
+function renderHTMLDocument(html) {
+  return `<!DOCTYPE html><html${joinAttrs(html.htmlAttrs)}><head>${joinTags(html.head)}</head><body${joinAttrs(html.bodyAttrs)}>${joinTags(html.bodyPrepend)}${joinTags(html.body)}${joinTags(html.bodyAppend)}</body></html>`;
+}

package/dist/runtime/middleware/no-ssr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, void>;
+export default _default;

package/dist/runtime/middleware/no-ssr.js

@@ -0,0 +1,7 @@
+import { defineEventHandler, getRequestHeader } from "h3";
+export default defineEventHandler((event) => {
+  if (getRequestHeader(event, "x-nuxt-no-ssr")) {
+    event.context.nuxt ||= {};
+    event.context.nuxt.noSSR = true;
+  }
+});

package/dist/runtime/plugins/dev-server-logs.d.ts

@@ -0,0 +1,3 @@
+import type { NitroApp } from 'nitropack/types';
+declare const _default: (nitroApp: NitroApp) => void;
+export default _default;

package/dist/runtime/plugins/dev-server-logs.js

@@ -0,0 +1,82 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { consola } from "consola";
+import { stringify } from "devalue";
+import { withTrailingSlash } from "ufo";
+import { getContext } from "unctx";
+import { captureRawStackTrace, parseRawStackTrace } from "errx";
+import { isVNode } from "vue";
+import { rootDir } from "#internal/dev-server-logs-options";
+import { appId } from "#internal/nuxt.config.mjs";
+const devReducers = {
+  VNode: (data) => isVNode(data) ? { type: data.type, props: data.props } : void 0,
+  URL: (data) => data instanceof URL ? data.toString() : void 0
+};
+const asyncContext = getContext("nuxt-dev", { asyncContext: true, AsyncLocalStorage });
+export default (nitroApp) => {
+  const handler = nitroApp.h3App.handler;
+  nitroApp.h3App.handler = (event) => {
+    return asyncContext.callAsync({ logs: [], event }, () => handler(event));
+  };
+  onConsoleLog((_log) => {
+    const ctx = asyncContext.tryUse();
+    if (!ctx) {
+      return;
+    }
+    const rawStack = captureRawStackTrace();
+    if (!rawStack || rawStack.includes("runtime/vite-node.mjs")) {
+      return;
+    }
+    const trace = [];
+    let filename = "";
+    for (const entry of parseRawStackTrace(rawStack)) {
+      if (entry.source === import.meta.url) {
+        continue;
+      }
+      if (EXCLUDE_TRACE_RE.test(entry.source)) {
+        continue;
+      }
+      filename ||= entry.source.replace(withTrailingSlash(rootDir), "");
+      trace.push({
+        ...entry,
+        source: entry.source.startsWith("file://") ? entry.source.replace("file://", "") : entry.source
+      });
+    }
+    const log = {
+      ..._log,
+      // Pass along filename to allow the client to display more info about where log comes from
+      filename,
+      // Clean up file names in stack trace
+      stack: trace
+    };
+    ctx.logs.push(log);
+  });
+  nitroApp.hooks.hook("afterResponse", () => {
+    const ctx = asyncContext.tryUse();
+    if (!ctx) {
+      return;
+    }
+    return nitroApp.hooks.callHook("dev:ssr-logs", { logs: ctx.logs, path: ctx.event.path });
+  });
+  nitroApp.hooks.hook("render:html", (htmlContext) => {
+    const ctx = asyncContext.tryUse();
+    if (!ctx) {
+      return;
+    }
+    try {
+      const reducers = Object.assign(/* @__PURE__ */ Object.create(null), devReducers, ctx.event.context._payloadReducers);
+      htmlContext.bodyAppend.unshift(`<script type="application/json" data-nuxt-logs="${appId}">${stringify(ctx.logs, reducers)}<\/script>`);
+    } catch (e) {
+      const shortError = e instanceof Error && "toString" in e ? ` Received \`${e.toString()}\`.` : "";
+      console.warn(`[nuxt] Failed to stringify dev server logs.${shortError} You can define your own reducer/reviver for rich types following the instructions in https://nuxt.com/docs/4.x/api/composables/use-nuxt-app#payload.`);
+    }
+  });
+};
+const EXCLUDE_TRACE_RE = /\/node_modules\/(?:.*\/)?(?:nuxt|nuxt-nightly|nuxt-edge|nuxt3|consola|@vue)\/|core\/runtime\/nitro/;
+function onConsoleLog(callback) {
+  consola.addReporter({
+    log(logObj) {
+      callback(logObj);
+    }
+  });
+  consola.wrapConsole();
+}

package/dist/runtime/templates/error-500.d.ts

@@ -0,0 +1,2 @@
+export type DefaultMessages = Record<"appName" | "statusCode" | "statusMessage" | "description" | "refresh", string | boolean | number>;
+export declare const template: (messages: Partial<DefaultMessages>) => string;

package/dist/runtime/templates/error-500.js

@@ -0,0 +1,6 @@
+import { escapeHtml } from "@vue/shared";
+const _messages = { "appName": "Nuxt", "statusCode": 500, "statusMessage": "Internal server error", "description": "This page is temporarily unavailable.", "refresh": "Refresh this page" };
+export const template = (messages) => {
+  messages = { ..._messages, ...messages };
+  return '<!DOCTYPE html><html lang="en"><head><title>' + escapeHtml(messages.statusCode) + " - " + escapeHtml(messages.statusMessage) + " | " + escapeHtml(messages.appName) + `</title><meta charset="utf-8"><meta content="width=device-width,initial-scale=1.0,minimum-scale=1.0" name="viewport"><script>!function(){const e=document.createElement("link").relList;if(!(e&&e.supports&&e.supports("modulepreload"))){for(const e of document.querySelectorAll('link[rel="modulepreload"]'))r(e);new MutationObserver(e=>{for(const o of e)if("childList"===o.type)for(const e of o.addedNodes)"LINK"===e.tagName&&"modulepreload"===e.rel&&r(e)}).observe(document,{childList:!0,subtree:!0})}function r(e){if(e.ep)return;e.ep=!0;const r=function(e){const r={};return e.integrity&&(r.integrity=e.integrity),e.referrerPolicy&&(r.referrerPolicy=e.referrerPolicy),"use-credentials"===e.crossOrigin?r.credentials="include":"anonymous"===e.crossOrigin?r.credentials="omit":r.credentials="same-origin",r}(e);fetch(e.href,r)}}();<\/script><style>*,:after,:before{border-color:var(--un-default-border-color,#e5e7eb);border-style:solid;border-width:0;box-sizing:border-box}:after,:before{--un-content:""}html{line-height:1.5;-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-feature-settings:normal;font-variation-settings:normal;-moz-tab-size:4;tab-size:4;-webkit-tap-highlight-color:transparent}body{line-height:inherit;margin:0}h1,h2{font-size:inherit;font-weight:inherit}h1,h2,p{margin:0}*,:after,:before{--un-rotate:0;--un-rotate-x:0;--un-rotate-y:0;--un-rotate-z:0;--un-scale-x:1;--un-scale-y:1;--un-scale-z:1;--un-skew-x:0;--un-skew-y:0;--un-translate-x:0;--un-translate-y:0;--un-translate-z:0;--un-pan-x: ;--un-pan-y: ;--un-pinch-zoom: ;--un-scroll-snap-strictness:proximity;--un-ordinal: ;--un-slashed-zero: ;--un-numeric-figure: ;--un-numeric-spacing: ;--un-numeric-fraction: ;--un-border-spacing-x:0;--un-border-spacing-y:0;--un-ring-offset-shadow:0 0 transparent;--un-ring-shadow:0 0 transparent;--un-shadow-inset: ;--un-shadow:0 0 transparent;--un-ring-inset: ;--un-ring-offset-width:0px;--un-ring-offset-color:#fff;--un-ring-width:0px;--un-ring-color:rgba(147,197,253,.5);--un-blur: ;--un-brightness: ;--un-contrast: ;--un-drop-shadow: ;--un-grayscale: ;--un-hue-rotate: ;--un-invert: ;--un-saturate: ;--un-sepia: ;--un-backdrop-blur: ;--un-backdrop-brightness: ;--un-backdrop-contrast: ;--un-backdrop-grayscale: ;--un-backdrop-hue-rotate: ;--un-backdrop-invert: ;--un-backdrop-opacity: ;--un-backdrop-saturate: ;--un-backdrop-sepia: }.grid{display:grid}.mb-2{margin-bottom:.5rem}.mb-4{margin-bottom:1rem}.max-w-520px{max-width:520px}.min-h-screen{min-height:100vh}.place-content-center{place-content:center}.overflow-hidden{overflow:hidden}.bg-white{--un-bg-opacity:1;background-color:rgb(255 255 255/var(--un-bg-opacity))}.px-2{padding-left:.5rem;padding-right:.5rem}.text-center{text-align:center}.text-\\[80px\\]{font-size:80px}.text-2xl{font-size:1.5rem;line-height:2rem}.text-\\[\\#020420\\]{--un-text-opacity:1;color:rgb(2 4 32/var(--un-text-opacity))}.text-\\[\\#64748B\\]{--un-text-opacity:1;color:rgb(100 116 139/var(--un-text-opacity))}.font-semibold{font-weight:600}.leading-none{line-height:1}.tracking-wide{letter-spacing:.025em}.font-sans{font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji}.tabular-nums{--un-numeric-spacing:tabular-nums;font-variant-numeric:var(--un-ordinal) var(--un-slashed-zero) var(--un-numeric-figure) var(--un-numeric-spacing) var(--un-numeric-fraction)}.antialiased{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}@media (prefers-color-scheme:dark){.dark\\:bg-\\[\\#020420\\]{--un-bg-opacity:1;background-color:rgb(2 4 32/var(--un-bg-opacity))}.dark\\:text-white{--un-text-opacity:1;color:rgb(255 255 255/var(--un-text-opacity))}}@media (min-width:640px){.sm\\:text-\\[110px\\]{font-size:110px}.sm\\:text-3xl{font-size:1.875rem;line-height:2.25rem}}</style></head><body class="antialiased bg-white dark:bg-[#020420] dark:text-white font-sans grid min-h-screen overflow-hidden place-content-center text-[#020420] tracking-wide"><div class="max-w-520px text-center"><h1 class="font-semibold leading-none mb-4 sm:text-[110px] tabular-nums text-[80px]">` + escapeHtml(messages.statusCode) + '</h1><h2 class="font-semibold mb-2 sm:text-3xl text-2xl">' + escapeHtml(messages.statusMessage) + '</h2><p class="mb-4 px-2 text-[#64748B] text-md">' + escapeHtml(messages.description) + "</p></div></body></html>";
+};

package/dist/runtime/utils/app-config.d.ts

@@ -0,0 +1,2 @@
+import type { H3Event } from 'h3';
+export declare function useAppConfig(event?: H3Event): any;

package/dist/runtime/utils/app-config.js

@@ -0,0 +1,25 @@
+import { klona } from "klona";
+import _inlineAppConfig from "#internal/nuxt/app-config";
+const _sharedAppConfig = _deepFreeze(klona(_inlineAppConfig));
+export function useAppConfig(event) {
+  if (!event) {
+    return _sharedAppConfig;
+  }
+  event.context.nuxt ||= {};
+  if (event.context.nuxt.appConfig) {
+    return event.context.nuxt.appConfig;
+  }
+  const appConfig = klona(_inlineAppConfig);
+  event.context.nuxt.appConfig = appConfig;
+  return appConfig;
+}
+function _deepFreeze(object) {
+  const propNames = Object.getOwnPropertyNames(object);
+  for (const name of propNames) {
+    const value = object[name];
+    if (value && typeof value === "object") {
+      _deepFreeze(value);
+    }
+  }
+  return Object.freeze(object);
+}

package/dist/runtime/utils/cache-driver.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (opts: any) => import("unstorage").Driver<any, never>;
+export default _default;

package/dist/runtime/utils/cache-driver.js

@@ -0,0 +1,34 @@
+// @ts-check
+
+import { defineDriver } from 'unstorage'
+import fsDriver from 'unstorage/drivers/fs-lite'
+import lruCache from 'unstorage/drivers/lru-cache'
+
+/**
+ * @param {string} item
+ */
+const normalizeFsKey = item => decodeURIComponent(item.replaceAll(':', '_'))
+
+/**
+ * @param {{ base: string }} opts
+ */
+export default defineDriver((opts) => {
+  const fs = fsDriver({ base: opts.base })
+  const lru = lruCache({ max: 1000 })
+
+  return {
+    ...fs, // fall back to file system - only the bottom three methods are used in renderer
+    async setItem (key, value, opts) {
+      await Promise.all([
+        fs.setItem?.(normalizeFsKey(key), value, opts),
+        lru.setItem?.(key, value, opts),
+      ])
+    },
+    async hasItem (key, opts) {
+      return await lru.hasItem(key, opts) || await fs.hasItem(normalizeFsKey(key), opts)
+    },
+    async getItem (key, opts) {
+      return await lru.getItem(key, opts) || await fs.getItem(normalizeFsKey(key), opts)
+    },
+  }
+})

package/dist/runtime/utils/cache.d.ts

@@ -0,0 +1,8 @@
+export declare const payloadCache: import("unstorage").Storage<import("unstorage").StorageValue> | null;
+export declare const islandCache: import("unstorage").Storage<import("unstorage").StorageValue> | null;
+export declare const islandPropCache: import("unstorage").Storage<import("unstorage").StorageValue> | null;
+export declare const sharedPrerenderPromises: Map<string, Promise<any>> | null;
+export declare const sharedPrerenderCache: {
+    get<T = unknown>(key: string): Promise<T> | undefined;
+    set<T>(key: string, value: Promise<T>): Promise<void>;
+} | null;

package/dist/runtime/utils/cache.js

@@ -0,0 +1,18 @@
+import { useStorage } from "nitropack/runtime";
+export const payloadCache = import.meta.prerender ? useStorage("internal:nuxt:prerender:payload") : null;
+export const islandCache = import.meta.prerender ? useStorage("internal:nuxt:prerender:island") : null;
+export const islandPropCache = import.meta.prerender ? useStorage("internal:nuxt:prerender:island-props") : null;
+export const sharedPrerenderPromises = import.meta.prerender && process.env.NUXT_SHARED_DATA ? /* @__PURE__ */ new Map() : null;
+const sharedPrerenderKeys = /* @__PURE__ */ new Set();
+export const sharedPrerenderCache = import.meta.prerender && process.env.NUXT_SHARED_DATA ? {
+  get(key) {
+    if (sharedPrerenderKeys.has(key)) {
+      return sharedPrerenderPromises.get(key) ?? useStorage("internal:nuxt:prerender:shared").getItem(key);
+    }
+  },
+  async set(key, value) {
+    sharedPrerenderKeys.add(key);
+    sharedPrerenderPromises.set(key, value);
+    useStorage("internal:nuxt:prerender:shared").setItem(key, await value).finally(() => sharedPrerenderPromises.delete(key));
+  }
+} : null;

package/dist/runtime/utils/config.d.ts

@@ -0,0 +1 @@
+export declare const defineAppConfig: (config: any) => any;

package/dist/runtime/utils/config.js

@@ -0,0 +1 @@
+export const defineAppConfig = (config) => config;

package/dist/runtime/utils/dev.d.ts

@@ -0,0 +1 @@
+export declare function generateErrorOverlayHTML(html: string): string;