nitro-nightly 3.1.0-20251028-004953-57503e42 → 3.1.0-20251028-110430-e607b753

package/dist/_build/vite.mjs

@@ -0,0 +1,3266 @@
+import { pathToFileURL } from 'node:url';
+import { colors } from 'consola/utils';
+import defu$1, { defu } from 'defu';
+import { m as mime } from '../_deps/mime.mjs';
+import { r as resolveNitroPath, p as prettyPath, s as scanUnprefixedPublicAssets, c as compressPublicAssets, w as writeFile, a as copyPublicAssets } from './assets.mjs';
+import { c as createRouter, a as addRoute, b as compileRouterToString, f as findRoute, d as findAllRoutes } from '../_deps/rou3.mjs';
+import { withLeadingSlash, withoutTrailingSlash, withTrailingSlash, parseURL, withBase, joinURL, withoutBase } from 'ufo';
+import { b as build$1 } from './build.mjs';
+import { a as scanAndSyncOptions, s as scanHandlers, r as runParallel } from './rolldown.mjs';
+import { z, P } from '../_deps/ultrahtml.mjs';
+import { a as resolve, j as join, n as normalize, r as relative, d as dirname$1, c as basename, i as isAbsolute } from '../_deps/pathe.mjs';
+import { fromNodeHandler, HTTPError, defineHandler, getRequestIP, getRequestURL, H3, toEventHandler, withBase as withBase$1 } from 'h3';
+import { version } from 'nitro/meta';
+import consola, { consola as consola$1 } from 'consola';
+import { readFile, rm, writeFile as writeFile$1, mkdir, readlink } from 'node:fs/promises';
+import { watch } from '../_deps/chokidar.mjs';
+import { serve, NodeRequest, sendNodeResponse } from 'srvx/node';
+import { d as debounce } from '../_deps/perfect-debounce.mjs';
+import { isDebug, isTest, isCI } from 'std-env';
+import { p as prepare } from './prepare.mjs';
+import './types.mjs';
+import { Hookable, createDebugger } from 'hookable';
+import { w as watchConfig, l as loadConfig } from '../_deps/c12.mjs';
+import { r as resolveCompatibilityDatesFromEnv, a as resolveCompatibilityDates, f as formatCompatibilityDate } from '../_deps/compatx.mjs';
+import { klona } from 'klona/full';
+import { runtimeDir, pkgDir, runtimeDependencies } from 'nitro/runtime/meta';
+import { existsSync, watch as watch$1 } from 'node:fs';
+import { e as escapeStringRegexp } from '../_deps/escape-string-regexp.mjs';
+import { r as resolveModuleExportNames, s as sanitizeFilePath } from '../_deps/mlly.mjs';
+import { f as findWorkspaceDir } from '../_deps/pkg-types.mjs';
+import { r as resolveModulePath } from '../_deps/exsolve.mjs';
+import { createJiti } from 'jiti';
+import { ofetch } from 'ofetch';
+import { c as createStorage } from './snapshot.mjs';
+import { hash } from 'ohash';
+import { c as createUnimport } from '../_deps/unimport.mjs';
+import 'node:zlib';
+import { Worker } from 'node:worker_threads';
+import { Agent } from 'undici';
+import { s as serveStatic } from '../_deps/serve-static.mjs';
+import { c as createProxyServer } from '../_deps/httpxy.mjs';
+import { resolve as resolve$1, dirname, join as join$1 } from 'node:path';
+import { ErrorParser } from 'youch-core';
+import { Youch } from 'youch';
+import { SourceMapConsumer } from 'source-map';
+import { FastResponse } from 'srvx';
+import { a as alias } from '../_deps/@rollup/plugin-alias.mjs';
+import { i as inject } from '../_deps/@rollup/plugin-inject.mjs';
+import { b as baseBuildPlugins, r as replace } from './plugins.mjs';
+import { b as baseBuildConfig } from './config.mjs';
+import 'klona';
+import 'unstorage';
+import { w as writeBuildInfo } from './info.mjs';
+import { DevEnvironment } from 'vite';
+import { getRandomPort } from 'get-port-please';
+import { spawn } from 'node:child_process';
+import { a as assetsPlugin } from '../_deps/@pi0/vite-plugin-fullstack.mjs';
+
+const NitroDefaults = {
+  // General
+  compatibilityDate: "latest",
+  debug: isDebug,
+  logLevel: isTest ? 1 : 3,
+  runtimeConfig: { app: {}, nitro: {} },
+  // Dirs
+  scanDirs: [],
+  buildDir: ".nitro",
+  output: {
+    dir: "{{ rootDir }}/.output",
+    serverDir: "{{ output.dir }}/server",
+    publicDir: "{{ output.dir }}/public"
+  },
+  // Features
+  experimental: {},
+  future: {},
+  storage: {},
+  devStorage: {},
+  bundledStorage: [],
+  publicAssets: [],
+  serverAssets: [],
+  plugins: [],
+  tasks: {},
+  scheduledTasks: {},
+  imports: false,
+  virtual: {},
+  compressPublicAssets: false,
+  ignore: [],
+  // Dev
+  dev: false,
+  devServer: { watch: [] },
+  watchOptions: { ignoreInitial: true },
+  devProxy: {},
+  // Logging
+  logging: {
+    compressedSizes: true,
+    buildSuccess: true
+  },
+  // Routing
+  baseURL: process.env.NITRO_APP_BASE_URL || "/",
+  handlers: [],
+  devHandlers: [],
+  errorHandler: void 0,
+  routeRules: {},
+  prerender: {
+    autoSubfolderIndex: true,
+    concurrency: 1,
+    interval: 0,
+    retry: 3,
+    retryDelay: 500,
+    failOnError: false,
+    crawlLinks: false,
+    ignore: [],
+    routes: []
+  },
+  // Rollup
+  builder: void 0,
+  moduleSideEffects: ["unenv/polyfill/", resolve(runtimeDir, "polyfill/")],
+  replace: {},
+  node: true,
+  sourceMap: true,
+  esbuild: {
+    options: {
+      jsxFactory: "h",
+      jsxFragment: "Fragment"
+    }
+  },
+  // Advanced
+  typescript: {
+    strict: true,
+    generateRuntimeConfigTypes: false,
+    generateTsConfig: false,
+    tsconfigPath: "types/tsconfig.json",
+    internalPaths: false,
+    tsConfig: {}
+  },
+  nodeModulesDirs: [],
+  hooks: {},
+  commands: {},
+  // Framework
+  framework: {
+    name: "nitro",
+    version: ""
+  }
+};
+
+async function resolveAssetsOptions(options) {
+  for (const publicAsset of options.publicAssets) {
+    publicAsset.dir = resolve(options.srcDir, publicAsset.dir);
+    publicAsset.baseURL = withLeadingSlash(
+      withoutTrailingSlash(publicAsset.baseURL || "/")
+    );
+  }
+  for (const dir of options.scanDirs) {
+    const publicDir = resolve(dir, "public");
+    if (!existsSync(publicDir)) {
+      continue;
+    }
+    if (options.publicAssets.some((asset) => asset.dir === publicDir)) {
+      continue;
+    }
+    options.publicAssets.push({ dir: publicDir });
+  }
+  for (const serverAsset of options.serverAssets) {
+    serverAsset.dir = resolve(options.srcDir, serverAsset.dir);
+  }
+  options.serverAssets.push({
+    baseName: "server",
+    dir: resolve(options.srcDir, "assets")
+  });
+  for (const asset of options.publicAssets) {
+    asset.baseURL = asset.baseURL || "/";
+    const isTopLevel = asset.baseURL === "/";
+    asset.fallthrough = asset.fallthrough ?? isTopLevel;
+    const routeRule = options.routeRules[asset.baseURL + "/**"];
+    asset.maxAge = routeRule?.cache?.maxAge ?? asset.maxAge ?? 0;
+    if (asset.maxAge && !asset.fallthrough) {
+      options.routeRules[asset.baseURL + "/**"] = defu(routeRule, {
+        headers: {
+          "cache-control": `public, max-age=${asset.maxAge}, immutable`
+        }
+      });
+    }
+  }
+}
+
+async function resolveCompatibilityOptions(options) {
+  options.compatibilityDate = resolveCompatibilityDatesFromEnv(
+    options.compatibilityDate
+  );
+}
+
+async function resolveDatabaseOptions(options) {
+  if (options.experimental.database && options.imports) {
+    options.imports.presets.push({
+      from: "nitro/runtime/internal/database",
+      imports: ["useDatabase"]
+    });
+    if (options.dev && !options.database && !options.devDatabase) {
+      options.devDatabase = {
+        default: {
+          connector: "sqlite",
+          options: {
+            cwd: options.rootDir
+          }
+        }
+      };
+    } else if (options.node && !options.database) {
+      options.database = {
+        default: {
+          connector: "sqlite",
+          options: {}
+        }
+      };
+    }
+  }
+}
+
+async function resolveExportConditionsOptions(options) {
+  options.exportConditions = _resolveExportConditions(
+    options.exportConditions || [],
+    { dev: options.dev, node: options.node, wasm: options.experimental.wasm }
+  );
+}
+function _resolveExportConditions(conditions, opts) {
+  const resolvedConditions = [];
+  resolvedConditions.push(opts.dev ? "development" : "production");
+  resolvedConditions.push(...conditions);
+  if (opts.node) {
+    resolvedConditions.push("node");
+  } else {
+    resolvedConditions.push(
+      "wintercg",
+      "worker",
+      "web",
+      "browser",
+      "workerd",
+      "edge-light",
+      "netlify",
+      "edge-routine",
+      "deno"
+    );
+  }
+  if (opts.wasm) {
+    resolvedConditions.push("wasm", "unwasm");
+  }
+  resolvedConditions.push("import", "default");
+  return resolvedConditions.filter(
+    (c, i) => resolvedConditions.indexOf(c) === i
+  );
+}
+
+async function resolveImportsOptions(options) {
+  if (options.imports === false) {
+    return;
+  }
+  options.imports.presets ??= [];
+  options.imports.presets.push(...getNitroImportsPreset());
+  const h3Exports = await resolveModuleExportNames("h3", {
+    url: import.meta.url
+  });
+  options.imports.presets ??= [];
+  options.imports.presets.push({
+    from: "h3",
+    imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+  });
+  options.imports.dirs ??= [];
+  options.imports.dirs.push(
+    ...options.scanDirs.map((dir) => join(dir, "utils/**/*"))
+  );
+  if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
+    options.imports.exclude.push(/[/\\]\.git[/\\]/);
+    options.imports.exclude.push(options.buildDir);
+    const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
+    options.imports.exclude.push(
+      scanDirsInNodeModules.length > 0 ? new RegExp(
+        `node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeStringRegexp(dir)).join("|")})`
+      ) : /[/\\]node_modules[/\\]/
+    );
+  }
+}
+function getNitroImportsPreset() {
+  return [
+    {
+      from: "nitro/runtime/internal/app",
+      imports: ["useNitroApp"]
+    },
+    {
+      from: "nitro/runtime/internal/runtime-config",
+      imports: ["useRuntimeConfig"]
+    },
+    {
+      from: "nitro/runtime/internal/plugin",
+      imports: ["defineNitroPlugin", "nitroPlugin"]
+    },
+    {
+      from: "nitro/runtime/internal/cache",
+      imports: [
+        "defineCachedFunction",
+        "defineCachedEventHandler",
+        "defineCachedHandler",
+        "cachedFunction",
+        "cachedEventHandler"
+      ]
+    },
+    {
+      from: "nitro/runtime/internal/storage",
+      imports: ["useStorage"]
+    },
+    {
+      from: "nitro/runtime/internal/renderer",
+      imports: ["defineRenderHandler"]
+    },
+    {
+      from: "nitro/runtime/internal/meta",
+      imports: ["defineRouteMeta"]
+    },
+    {
+      from: "nitro/runtime/internal/route-rules",
+      imports: ["getRouteRules"]
+    },
+    {
+      from: "nitro/runtime/internal/context",
+      imports: ["useRequest"]
+    },
+    {
+      from: "nitro/runtime/internal/task",
+      imports: ["defineTask", "runTask"]
+    },
+    {
+      from: "nitro/runtime/internal/error/utils",
+      imports: ["defineNitroErrorHandler"]
+    },
+    {
+      from: "nitro/deps/ofetch",
+      imports: ["$fetch"]
+    }
+  ];
+}
+
+async function resolveOpenAPIOptions(options) {
+  if (!options.experimental.openAPI) {
+    return;
+  }
+  if (!options.dev && !options.openAPI?.production) {
+    return;
+  }
+  const shouldPrerender = !options.dev && options.openAPI?.production === "prerender";
+  const handlersEnv = shouldPrerender ? "prerender" : "";
+  const prerenderRoutes = [];
+  const jsonRoute = options.openAPI?.route || "/_openapi.json";
+  prerenderRoutes.push(jsonRoute);
+  options.handlers.push({
+    route: jsonRoute,
+    env: handlersEnv,
+    handler: join(runtimeDir, "internal/routes/openapi")
+  });
+  if (options.openAPI?.ui?.scalar !== false) {
+    const scalarRoute = options.openAPI?.ui?.scalar?.route || "/_scalar";
+    prerenderRoutes.push(scalarRoute);
+    options.handlers.push({
+      route: options.openAPI?.ui?.scalar?.route || "/_scalar",
+      env: handlersEnv,
+      handler: join(runtimeDir, "internal/routes/scalar")
+    });
+  }
+  if (options.openAPI?.ui?.swagger !== false) {
+    const swaggerRoute = options.openAPI?.ui?.swagger?.route || "/_swagger";
+    prerenderRoutes.push(swaggerRoute);
+    options.handlers.push({
+      route: swaggerRoute,
+      env: handlersEnv,
+      handler: join(runtimeDir, "internal/routes/swagger")
+    });
+  }
+  if (shouldPrerender) {
+    options.prerender ??= {};
+    options.prerender.routes ??= [];
+    options.prerender.routes.push(...prerenderRoutes);
+  }
+}
+
+const RESOLVE_EXTENSIONS = [".ts", ".js", ".mts", ".mjs", ".tsx", ".jsx"];
+async function resolvePathOptions(options) {
+  options.rootDir = resolve(options.rootDir || ".") + "/";
+  options.workspaceDir ||= await findWorkspaceDir(options.rootDir).catch(() => options.rootDir) + "/";
+  for (const key of ["srcDir", "buildDir"]) {
+    options[key] = resolve(options.rootDir, options[key] || ".");
+  }
+  options.alias ??= {};
+  if (!options.static && !options.entry) {
+    throw new Error(
+      `Nitro entry is missing! Is "${options.preset}" preset correct?`
+    );
+  }
+  if (options.entry) {
+    options.entry = resolveNitroPath(options.entry, options);
+  }
+  options.output.dir = resolveNitroPath(
+    options.output.dir || NitroDefaults.output.dir,
+    options,
+    options.rootDir
+  ) + "/";
+  options.output.publicDir = resolveNitroPath(
+    options.output.publicDir || NitroDefaults.output.publicDir,
+    options,
+    options.rootDir
+  ) + "/";
+  options.output.serverDir = resolveNitroPath(
+    options.output.serverDir || NitroDefaults.output.serverDir,
+    options,
+    options.rootDir
+  ) + "/";
+  options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, "dist/node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, ".."));
+  options.nodeModulesDirs = [
+    ...new Set(
+      // Adding trailing slash to optimize resolve performance (path is explicitly a dir)
+      options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir) + "/")
+    )
+  ];
+  options.plugins = options.plugins.map((p) => resolveNitroPath(p, options));
+  options.scanDirs.unshift(options.srcDir);
+  options.scanDirs = options.scanDirs.map(
+    (dir) => resolve(options.srcDir, dir)
+  );
+  options.scanDirs = [...new Set(options.scanDirs.map((dir) => dir + "/"))];
+  if (options.serverEntry) {
+    options.serverEntry = resolveModulePath(
+      resolveNitroPath(options.serverEntry, options),
+      {
+        from: options.scanDirs,
+        extensions: RESOLVE_EXTENSIONS
+      }
+    );
+  } else {
+    const defaultServerEntry = resolveModulePath("./server", {
+      from: options.scanDirs,
+      extensions: RESOLVE_EXTENSIONS,
+      try: true
+    });
+    if (defaultServerEntry) {
+      options.serverEntry = defaultServerEntry;
+      consola.info(
+        `Using \`${prettyPath(defaultServerEntry)}\` as server entry.`
+      );
+    }
+  }
+  if (options.renderer?.entry) {
+    options.renderer.entry = resolveModulePath(
+      resolveNitroPath(options.renderer?.entry, options),
+      {
+        from: options.scanDirs,
+        extensions: RESOLVE_EXTENSIONS
+      }
+    );
+  }
+  if (options.renderer?.template) {
+    options.renderer.template = resolveModulePath(
+      resolveNitroPath(options.renderer?.template, options),
+      {
+        from: options.scanDirs,
+        extensions: [".html"]
+      }
+    );
+  } else if (!options.renderer?.entry) {
+    const defaultIndex = resolveModulePath("./index.html", {
+      from: options.scanDirs,
+      extensions: [".html"],
+      try: true
+    });
+    if (defaultIndex) {
+      options.renderer ??= {};
+      options.renderer.template = defaultIndex;
+      consola.info(
+        `Using \`${prettyPath(defaultIndex)}\` as renderer template.`
+      );
+    }
+  }
+  if (options.renderer?.template && !options.renderer?.entry) {
+    options.renderer ??= {};
+    options.renderer.entry = join(
+      runtimeDir,
+      "internal/routes/renderer-template" + (options.dev ? ".dev" : "")
+    );
+  }
+}
+
+async function resolveRouteRulesOptions(options) {
+  options.routeRules = defu(options.routeRules, options.routes || {});
+  options.routeRules = normalizeRouteRules(options);
+}
+function normalizeRouteRules(config) {
+  const normalizedRules = {};
+  for (let path in config.routeRules) {
+    const routeConfig = config.routeRules[path];
+    path = withLeadingSlash(path);
+    const routeRules = {
+      ...routeConfig,
+      redirect: void 0,
+      proxy: void 0
+    };
+    if (routeConfig.redirect) {
+      routeRules.redirect = {
+        // @ts-ignore
+        to: "/",
+        status: 307,
+        ...typeof routeConfig.redirect === "string" ? { to: routeConfig.redirect } : routeConfig.redirect
+      };
+      if (path.endsWith("/**")) {
+        routeRules.redirect._redirectStripBase = path.slice(0, -3);
+      }
+    }
+    if (routeConfig.proxy) {
+      routeRules.proxy = typeof routeConfig.proxy === "string" ? { to: routeConfig.proxy } : routeConfig.proxy;
+      if (path.endsWith("/**")) {
+        routeRules.proxy._proxyStripBase = path.slice(0, -3);
+      }
+    }
+    if (routeConfig.cors) {
+      routeRules.headers = {
+        "access-control-allow-origin": "*",
+        "access-control-allow-methods": "*",
+        "access-control-allow-headers": "*",
+        "access-control-max-age": "0",
+        ...routeRules.headers
+      };
+    }
+    if (routeConfig.swr) {
+      routeRules.cache = routeRules.cache || {};
+      routeRules.cache.swr = true;
+      if (typeof routeConfig.swr === "number") {
+        routeRules.cache.maxAge = routeConfig.swr;
+      }
+    }
+    if (routeConfig.cache === false) {
+      routeRules.cache = false;
+    }
+    normalizedRules[path] = routeRules;
+  }
+  return normalizedRules;
+}
+
+async function resolveRuntimeConfigOptions(options) {
+  options.runtimeConfig = normalizeRuntimeConfig(options);
+}
+function normalizeRuntimeConfig(config) {
+  provideFallbackValues(config.runtimeConfig || {});
+  const runtimeConfig = defu$1(
+    config.runtimeConfig,
+    {
+      app: {
+        baseURL: config.baseURL
+      },
+      nitro: {
+        envExpansion: config.experimental?.envExpansion,
+        openAPI: config.openAPI
+      }
+    }
+  );
+  runtimeConfig.nitro.routeRules = config.routeRules;
+  checkSerializableRuntimeConfig(runtimeConfig);
+  return runtimeConfig;
+}
+function provideFallbackValues(obj) {
+  for (const key in obj) {
+    if (obj[key] === void 0 || obj[key] === null) {
+      obj[key] = "";
+    } else if (typeof obj[key] === "object") {
+      provideFallbackValues(obj[key]);
+    }
+  }
+}
+function checkSerializableRuntimeConfig(obj, path = []) {
+  if (isPrimitiveValue(obj)) {
+    return;
+  }
+  for (const key in obj) {
+    const value = obj[key];
+    if (value === null || value === void 0 || isPrimitiveValue(value)) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const [index, item] of value.entries())
+        checkSerializableRuntimeConfig(item, [...path, `${key}[${index}]`]);
+    } else if (typeof value === "object" && value.constructor === Object && (!value.constructor?.name || value.constructor.name === "Object")) {
+      checkSerializableRuntimeConfig(value, [...path, key]);
+    } else {
+      console.warn(
+        `Runtime config option \`${[...path, key].join(".")}\` may not be able to be serialized.`
+      );
+    }
+  }
+}
+function isPrimitiveValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+async function resolveStorageOptions(options) {
+  const fsMounts = {
+    root: resolve(options.rootDir),
+    src: resolve(options.srcDir),
+    build: resolve(options.buildDir),
+    cache: resolve(options.buildDir, "cache")
+  };
+  for (const p in fsMounts) {
+    options.devStorage[p] = options.devStorage[p] || {
+      driver: "fs",
+      readOnly: p === "root" || p === "src",
+      base: fsMounts[p]
+    };
+  }
+  if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) {
+    options.devStorage.data = {
+      driver: "fs",
+      base: resolve(options.rootDir, ".data/kv")
+    };
+  } else if (options.node && options.storage.data === void 0) {
+    options.storage.data = {
+      driver: "fsLite",
+      base: "./.data/kv"
+    };
+  }
+}
+
+async function resolveURLOptions(options) {
+  options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
+}
+
+async function resolveErrorOptions(options) {
+  if (!options.errorHandler) {
+    options.errorHandler = [];
+  } else if (!Array.isArray(options.errorHandler)) {
+    options.errorHandler = [options.errorHandler];
+  }
+  options.errorHandler.push(
+    join(runtimeDir, `internal/error/${options.dev ? "dev" : "prod"}`)
+  );
+}
+
+const common = {
+  meta: {
+    name: "nitro-common",
+    url: import.meta.url
+  },
+  alias: {
+    "buffer/": "node:buffer",
+    "buffer/index": "node:buffer",
+    "buffer/index.js": "node:buffer",
+    "string_decoder/": "node:string_decoder",
+    "process/": "node:process"
+  }
+};
+const nodeless = {
+  meta: {
+    name: "nitro-nodeless",
+    url: import.meta.url
+  },
+  inject: {
+    global: "unenv/polyfill/globalthis",
+    process: "node:process",
+    Buffer: ["node:buffer", "Buffer"],
+    clearImmediate: ["node:timers", "clearImmediate"],
+    setImmediate: ["node:timers", "setImmediate"],
+    performance: "unenv/polyfill/performance",
+    PerformanceObserver: ["node:perf_hooks", "PerformanceObserver"],
+    BroadcastChannel: ["node:worker_threads", "BroadcastChannel"]
+  },
+  polyfill: [
+    "unenv/polyfill/globalthis-global",
+    "unenv/polyfill/process",
+    "unenv/polyfill/buffer",
+    "unenv/polyfill/timers"
+  ]
+};
+async function resolveUnenv(options) {
+  options.unenv ??= [];
+  if (!Array.isArray(options.unenv)) {
+    options.unenv = [options.unenv];
+  }
+  options.unenv = options.unenv.filter(Boolean);
+  if (!options.node) {
+    options.unenv.unshift(nodeless);
+  }
+  options.unenv.unshift(common);
+}
+
+async function resolveBuilder(options) {
+  if (!options.builder) {
+    options.builder = process.env.NITRO_BUILDER || "rollup";
+  }
+  if (options.builder === "rolldown") {
+    try {
+      await import('rolldown');
+    } catch {
+      throw new Error(
+        `Builder "rolldown" is not available. Make sure to install "rolldown" package.`
+      );
+    }
+  } else if (options.builder === "vite") {
+    try {
+      await import('vite');
+    } catch {
+      throw new Error(
+        `Builder "vite" is not available. Make sure to install "vite" package.`
+      );
+    }
+  }
+  if (!["rollup", "rolldown", "vite"].includes(options.builder)) {
+    throw new Error(`Builder "${options.builder}" is not supported.`);
+  }
+}
+
+const configResolvers = [
+  resolveCompatibilityOptions,
+  resolvePathOptions,
+  resolveImportsOptions,
+  resolveRouteRulesOptions,
+  resolveDatabaseOptions,
+  resolveExportConditionsOptions,
+  resolveRuntimeConfigOptions,
+  resolveOpenAPIOptions,
+  resolveURLOptions,
+  resolveAssetsOptions,
+  resolveStorageOptions,
+  resolveErrorOptions,
+  resolveUnenv,
+  resolveBuilder
+];
+async function loadOptions(configOverrides = {}, opts = {}) {
+  const options = await _loadUserConfig(configOverrides, opts);
+  for (const resolver of configResolvers) {
+    await resolver(options);
+  }
+  return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}) {
+  configOverrides = klona(configOverrides);
+  globalThis.defineNitroConfig = globalThis.defineNitroConfig || ((c) => c);
+  let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || (process.env.NITRO_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE);
+  const { resolvePreset } = await import('../_presets/index.mjs');
+  let preset = configOverrides.preset || process.env.NITRO_PRESET || process.env.SERVER_PRESET;
+  const _dotenv = opts.dotenv ?? (configOverrides.dev && { fileName: [".env", ".env.local"] });
+  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+    name: "nitro",
+    cwd: configOverrides.rootDir,
+    dotenv: _dotenv,
+    extend: { extendKey: ["extends", "preset"] },
+    defaults: NitroDefaults,
+    jitiOptions: {
+      alias: {
+        nitropack: "nitro/config",
+        "nitro/config": "nitro/config"
+      }
+    },
+    async overrides({ rawConfigs }) {
+      const getConf = (key) => configOverrides[key] ?? rawConfigs.main?.[key] ?? rawConfigs.rc?.[key] ?? rawConfigs.packageJson?.[key];
+      if (!compatibilityDate) {
+        compatibilityDate = getConf("compatibilityDate");
+      }
+      const framework = getConf("framework");
+      const isCustomFramework = framework?.name && framework.name !== "nitro";
+      if (!preset) {
+        preset = getConf("preset");
+      }
+      if (configOverrides.dev) {
+        preset = preset && preset !== "nitro-dev" ? await resolvePreset(preset, {
+          static: getConf("static"),
+          dev: true,
+          compatibilityDate: compatibilityDate || "latest"
+        }).then((p) => p?._meta?.name || "nitro-dev").catch(() => "nitro-dev") : "nitro-dev";
+      } else if (!preset) {
+        preset = await resolvePreset("", {
+          static: getConf("static"),
+          dev: false,
+          compatibilityDate: compatibilityDate || "latest"
+        }).then((p) => p?._meta?.name);
+      }
+      return {
+        ...configOverrides,
+        preset,
+        typescript: {
+          generateRuntimeConfigTypes: !isCustomFramework,
+          ...getConf("typescript"),
+          ...configOverrides.typescript
+        }
+      };
+    },
+    async resolve(id) {
+      const preset2 = await resolvePreset(id, {
+        static: configOverrides.static,
+        compatibilityDate: compatibilityDate || "latest",
+        dev: configOverrides.dev
+      });
+      if (preset2) {
+        return {
+          config: klona(preset2)
+        };
+      }
+    },
+    ...opts.c12
+  });
+  const options = klona(loadedConfig.config);
+  options._config = configOverrides;
+  options._c12 = loadedConfig;
+  const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || preset;
+  options.preset = _presetName;
+  options.compatibilityDate = resolveCompatibilityDates(
+    compatibilityDate,
+    options.compatibilityDate
+  );
+  if (options.dev && options.preset !== "nitro-dev") {
+    consola.info(`Using \`${options.preset}\` emulation in development mode.`);
+  }
+  return options;
+}
+
+async function updateNitroConfig(nitro, config) {
+  nitro.options.routeRules = normalizeRouteRules(
+    config.routeRules ? config : nitro.options
+  );
+  nitro.options.runtimeConfig = normalizeRuntimeConfig(
+    config.runtimeConfig ? config : nitro.options
+  );
+  await nitro.hooks.callHook("rollup:reload");
+  consola.success("Nitro config hot reloaded!");
+}
+
+async function installModules(nitro) {
+  const _modules = [...nitro.options.modules || []];
+  const modules = await Promise.all(
+    _modules.map((mod) => _resolveNitroModule(mod, nitro.options))
+  );
+  const _installedURLs = /* @__PURE__ */ new Set();
+  for (const mod of modules) {
+    if (mod._url) {
+      if (_installedURLs.has(mod._url)) {
+        continue;
+      }
+      _installedURLs.add(mod._url);
+    }
+    await mod.setup(nitro);
+  }
+}
+async function _resolveNitroModule(mod, nitroOptions) {
+  let _url;
+  if (typeof mod === "string") {
+    globalThis.defineNitroModule = // @ts-ignore
+    globalThis.defineNitroModule || ((mod2) => mod2);
+    const jiti = createJiti(nitroOptions.rootDir, {
+      alias: nitroOptions.alias
+    });
+    const _modPath = jiti.esmResolve(mod);
+    _url = _modPath;
+    mod = await jiti.import(_modPath, { default: true });
+  }
+  if (typeof mod === "function") {
+    mod = { setup: mod };
+  }
+  if (!mod.setup) {
+    mod.setup = () => {
+    };
+  }
+  return {
+    _url,
+    ...mod
+  };
+}
+
+async function runTask(taskEvent, opts) {
+  const ctx = await _getTasksContext(opts);
+  const result = await ctx.devFetch(`/_nitro/tasks/${taskEvent.name}`, {
+    method: "POST",
+    body: taskEvent
+  });
+  return result;
+}
+async function listTasks(opts) {
+  const ctx = await _getTasksContext(opts);
+  const res = await ctx.devFetch("/_nitro/tasks");
+  return res.tasks;
+}
+function addNitroTasksVirtualFile(nitro) {
+  nitro.options.virtual["#nitro-internal-virtual/tasks"] = () => {
+    const _scheduledTasks = Object.entries(nitro.options.scheduledTasks || {}).map(([cron, _tasks]) => {
+      const tasks = (Array.isArray(_tasks) ? _tasks : [_tasks]).filter(
+        (name) => {
+          if (!nitro.options.tasks[name]) {
+            nitro.logger.warn(`Scheduled task \`${name}\` is not defined!`);
+            return false;
+          }
+          return true;
+        }
+      );
+      return { cron, tasks };
+    }).filter((e) => e.tasks.length > 0);
+    const scheduledTasks = _scheduledTasks.length > 0 ? _scheduledTasks : false;
+    return (
+      /* js */
+      `
+export const scheduledTasks = ${JSON.stringify(scheduledTasks)};
+
+export const tasks = {
+  ${Object.entries(nitro.options.tasks).map(
+        ([name, task]) => `"${name}": {
+          meta: {
+            description: ${JSON.stringify(task.description)},
+          },
+          resolve: ${task.handler ? `() => import("${normalize(
+          task.handler
+        )}").then(r => r.default || r)` : "undefined"},
+        }`
+      ).join(",\n")}
+};`
+    );
+  };
+}
+const _devHint = `(is dev server running?)`;
+async function _getTasksContext(opts) {
+  const cwd = resolve(process.cwd(), opts?.cwd || ".");
+  const outDir = resolve(cwd, opts?.buildDir || ".nitro");
+  const buildInfoPath = resolve(outDir, "nitro.json");
+  if (!existsSync(buildInfoPath)) {
+    throw new Error(`Missing info file: \`${buildInfoPath}\` ${_devHint}`);
+  }
+  const buildInfo = JSON.parse(
+    await readFile(buildInfoPath, "utf8")
+  );
+  if (!buildInfo.dev?.pid || !buildInfo.dev?.workerAddress) {
+    throw new Error(
+      `Missing dev server info in: \`${buildInfoPath}\` ${_devHint}`
+    );
+  }
+  if (!_pidIsRunning(buildInfo.dev.pid)) {
+    throw new Error(`Dev server is not running (pid: ${buildInfo.dev.pid})`);
+  }
+  const devFetch = ofetch.create({
+    baseURL: `http://${buildInfo.dev.workerAddress.host || "localhost"}:${buildInfo.dev.workerAddress.port || "3000"}`,
+    // @ts-expect-error
+    socketPath: buildInfo.dev.workerAddress.socketPath
+  });
+  return {
+    buildInfo,
+    devFetch
+  };
+}
+function _pidIsRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const isGlobalMiddleware = (h) => !h.method && (!h.route || h.route === "/**");
+function initNitroRouting(nitro) {
+  const envConditions = new Set(
+    [
+      nitro.options.dev ? "dev" : "prod",
+      nitro.options.preset,
+      nitro.options.preset === "nitro-prerender" ? "prerender" : void 0
+    ].filter(Boolean)
+  );
+  const matchesEnv = (h) => {
+    const hEnv = Array.isArray(h.env) ? h.env : [h.env];
+    const envs = hEnv.filter(Boolean);
+    return envs.length === 0 || envs.some((env) => envConditions.has(env));
+  };
+  const routes = new Router();
+  const routeRules = new Router(
+    true
+    /* matchAll */
+  );
+  const globalMiddleware = [];
+  const routedMiddleware = new Router(
+    true
+    /* matchAll */
+  );
+  const warns = /* @__PURE__ */ new Set();
+  const sync = () => {
+    routeRules._update(
+      Object.entries(nitro.options.routeRules).map(([route, data]) => ({
+        route,
+        method: "",
+        data: {
+          ...data,
+          _route: route
+        }
+      }))
+    );
+    const _routes = [
+      ...nitro.scannedHandlers,
+      ...nitro.options.handlers
+    ].filter((h) => h && !h.middleware && matchesEnv(h));
+    if (nitro.options.renderer?.entry) {
+      const existingWildcard = _routes.findIndex(
+        (h) => /^\/\*\*(:.+)?$/.test(h.route) && (!h.method || h.method === "GET")
+      );
+      if (existingWildcard !== -1) {
+        const h = _routes[existingWildcard];
+        const warn = `The renderer will override \`${relative(".", h.handler)}\` (route: \`${h.route}\`). Use a more specific route or different HTTP method.`;
+        if (!warns.has(warn)) {
+          warns.add(warn);
+          nitro.logger.warn(warn);
+        }
+        _routes.splice(existingWildcard, 1);
+      }
+      _routes.push({
+        route: "/**",
+        lazy: true,
+        handler: nitro.options.renderer?.entry
+      });
+    }
+    routes._update(
+      _routes.map((h) => ({
+        ...h,
+        method: h.method || "",
+        data: handlerWithImportHash(h)
+      }))
+    );
+    const _middleware = [
+      ...nitro.scannedHandlers,
+      ...nitro.options.handlers
+    ].filter((h) => h && h.middleware && matchesEnv(h));
+    if (nitro.options.serveStatic) {
+      _middleware.unshift({
+        route: "/**",
+        middleware: true,
+        handler: join(runtimeDir, "internal/static")
+      });
+    }
+    globalMiddleware.splice(
+      0,
+      globalMiddleware.length,
+      ..._middleware.filter((h) => isGlobalMiddleware(h)).map((m) => handlerWithImportHash(m))
+    );
+    routedMiddleware._update(
+      _middleware.filter((h) => !isGlobalMiddleware(h)).map((h) => ({
+        ...h,
+        method: h.method || "",
+        data: handlerWithImportHash(h)
+      }))
+    );
+  };
+  nitro.routing = Object.freeze({
+    sync,
+    routes,
+    routeRules,
+    globalMiddleware,
+    routedMiddleware
+  });
+}
+function handlerWithImportHash(h) {
+  const id = (h.lazy ? "_lazy_" : "_") + hash(h.handler).replace(/-/g, "").slice(0, 6);
+  return { ...h, _importHash: id };
+}
+class Router {
+  #routes;
+  #router;
+  #compiled;
+  constructor(matchAll) {
+    this._update([]);
+  }
+  get routes() {
+    return this.#routes;
+  }
+  _update(routes) {
+    this.#routes = routes;
+    this.#router = createRouter();
+    this.#compiled = void 0;
+    for (const route of routes) {
+      addRoute(this.#router, route.method, route.route, route.data);
+    }
+  }
+  hasRoutes() {
+    return this.#routes.length > 0;
+  }
+  compileToString(opts) {
+    return this.#compiled || (this.#compiled = compileRouterToString(this.#router, void 0, opts));
+  }
+  match(method, path) {
+    return findRoute(this.#router, method, path)?.data;
+  }
+  matchAll(method, path) {
+    return findAllRoutes(this.#router, method, path).map(
+      (route) => route.data
+    );
+  }
+}
+
+async function createNitro(config = {}, opts = {}) {
+  const options = await loadOptions(config, opts);
+  const nitro = {
+    options,
+    hooks: new Hookable(),
+    vfs: {},
+    routing: {},
+    logger: consola$1.withTag("nitro"),
+    scannedHandlers: [],
+    close: () => nitro.hooks.callHook("close"),
+    storage: void 0,
+    async updateConfig(config2) {
+      updateNitroConfig(nitro, config2);
+    }
+  };
+  initNitroRouting(nitro);
+  await scanAndSyncOptions(nitro);
+  nitro.storage = await createStorage(nitro);
+  nitro.hooks.hook("close", async () => {
+    await nitro.storage.dispose();
+  });
+  if (nitro.options.debug) {
+    createDebugger(nitro.hooks, { tag: "nitro" });
+  }
+  if (nitro.options.logLevel !== void 0) {
+    nitro.logger.level = nitro.options.logLevel;
+  }
+  nitro.hooks.addHooks(nitro.options.hooks);
+  addNitroTasksVirtualFile(nitro);
+  await installModules(nitro);
+  if (nitro.options.imports) {
+    nitro.unimport = createUnimport(nitro.options.imports);
+    await nitro.unimport.init();
+    nitro.options.virtual["#imports"] = () => nitro.unimport?.toExports() || "";
+    nitro.options.virtual["#nitro"] = 'export * from "#imports"';
+  }
+  await scanHandlers(nitro);
+  nitro.routing.sync();
+  return nitro;
+}
+
+const allowedExtensions = /* @__PURE__ */ new Set(["", ".json"]);
+const linkParents$1 = /* @__PURE__ */ new Map();
+const HTML_ENTITIES = {
+  "&lt;": "<",
+  "&gt;": ">",
+  "&amp;": "&",
+  "&apos;": "'",
+  "&quot;": '"'
+};
+function escapeHtml(text) {
+  return text.replace(
+    /&(lt|gt|amp|apos|quot);/g,
+    (ch) => HTML_ENTITIES[ch] || ch
+  );
+}
+async function extractLinks(html, from, res, crawlLinks) {
+  const links = [];
+  const _links = [];
+  if (crawlLinks) {
+    await z(P(html), (node) => {
+      if (!node.attributes?.href) {
+        return;
+      }
+      const link = escapeHtml(node.attributes.href);
+      if (!decodeURIComponent(link).startsWith("#") && allowedExtensions.has(getExtension(link))) {
+        _links.push(link);
+      }
+    });
+  }
+  const header = res.headers.get("x-nitro-prerender") || "";
+  _links.push(...header.split(",").map((i) => decodeURIComponent(i.trim())));
+  for (const link of _links.filter(Boolean)) {
+    const _link = parseURL(link);
+    if (_link.protocol || _link.host) {
+      continue;
+    }
+    if (!_link.pathname.startsWith("/")) {
+      const fromURL = new URL(from, "http://localhost");
+      _link.pathname = new URL(_link.pathname, fromURL).pathname;
+    }
+    links.push(_link.pathname + _link.search);
+  }
+  for (const link of links) {
+    const _parents = linkParents$1.get(link);
+    if (_parents) {
+      _parents.add(from);
+    } else {
+      linkParents$1.set(link, /* @__PURE__ */ new Set([from]));
+    }
+  }
+  return links;
+}
+const EXT_REGEX = /\.[\da-z]+$/;
+function getExtension(link) {
+  const pathname = parseURL(link).pathname;
+  return (pathname.match(EXT_REGEX) || [])[0] || "";
+}
+function formatPrerenderRoute(route) {
+  let str = `  \u251C\u2500 ${route.route} (${route.generateTimeMS}ms)`;
+  if (route.error) {
+    const parents = linkParents$1.get(route.route);
+    const errorColor = colors[route.error.status === 404 ? "yellow" : "red"];
+    const errorLead = parents?.size ? "\u251C\u2500\u2500" : "\u2514\u2500\u2500";
+    str += `
+  \u2502 ${errorLead} ${errorColor(route.error.message)}`;
+    if (parents?.size) {
+      str += `
+${[...parents.values()].map((link) => `  \u2502 \u2514\u2500\u2500 Linked from ${link}`).join("\n")}`;
+    }
+  }
+  if (route.skip) {
+    str += colors.gray(" (skipped)");
+  }
+  return colors.gray(str);
+}
+function matchesIgnorePattern(path, pattern) {
+  if (typeof pattern === "string") {
+    return path.startsWith(pattern);
+  }
+  if (typeof pattern === "function") {
+    return pattern(path) === true;
+  }
+  if (pattern instanceof RegExp) {
+    return pattern.test(path);
+  }
+  return false;
+}
+
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+const linkParents = /* @__PURE__ */ new Map();
+async function prerender(nitro) {
+  if (nitro.options.noPublicDir) {
+    nitro.logger.warn(
+      "Skipping prerender since `noPublicDir` option is enabled."
+    );
+    return;
+  }
+  if (nitro.options.builder === "vite") {
+    nitro.logger.warn(
+      "Skipping prerender since not supported with vite builder yet..."
+    );
+    return;
+  }
+  const routes = new Set(nitro.options.prerender.routes);
+  const prerenderRulePaths = Object.entries(nitro.options.routeRules).filter(([path2, options]) => options.prerender && !path2.includes("*")).map((e) => e[0]);
+  for (const route of prerenderRulePaths) {
+    routes.add(route);
+  }
+  await nitro.hooks.callHook("prerender:routes", routes);
+  if (routes.size === 0) {
+    if (nitro.options.prerender.crawlLinks) {
+      routes.add("/");
+    } else {
+      return;
+    }
+  }
+  nitro.logger.info("Initializing prerenderer");
+  nitro._prerenderedRoutes = [];
+  nitro._prerenderMeta = nitro._prerenderMeta || {};
+  const prerendererConfig = {
+    ...nitro.options._config,
+    static: false,
+    rootDir: nitro.options.rootDir,
+    logLevel: 0,
+    preset: "nitro-prerender"
+  };
+  await nitro.hooks.callHook("prerender:config", prerendererConfig);
+  const nitroRenderer = await createNitro(prerendererConfig);
+  const prerenderStartTime = Date.now();
+  await nitro.hooks.callHook("prerender:init", nitroRenderer);
+  let path = relative(nitro.options.output.dir, nitro.options.output.publicDir);
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  nitroRenderer.options.commands.preview = `npx serve ${path}`;
+  nitroRenderer.options.output.dir = nitro.options.output.dir;
+  await build$1(nitroRenderer);
+  const serverFilename = typeof nitroRenderer.options.rollupConfig?.output?.entryFileNames === "string" ? nitroRenderer.options.rollupConfig.output.entryFileNames : "index.mjs";
+  const serverEntrypoint = resolve(
+    nitroRenderer.options.output.serverDir,
+    serverFilename
+  );
+  const { closePrerenderer, appFetch } = await import(pathToFileURL(serverEntrypoint).href);
+  const routeRules = createRouter();
+  for (const [route, rules] of Object.entries(nitro.options.routeRules)) {
+    addRoute(routeRules, void 0, route, rules);
+  }
+  const _getRouteRules = (path2) => defu(
+    {},
+    ...findAllRoutes(routeRules, void 0, path2).map((r) => r.data).reverse()
+  );
+  const generatedRoutes = /* @__PURE__ */ new Set();
+  const failedRoutes = /* @__PURE__ */ new Set();
+  const skippedRoutes = /* @__PURE__ */ new Set();
+  const displayedLengthWarns = /* @__PURE__ */ new Set();
+  const publicAssetBases = nitro.options.publicAssets.filter(
+    (a) => !!a.baseURL && a.baseURL !== "/" && !a.fallthrough
+  ).map((a) => withTrailingSlash(a.baseURL));
+  const scannedPublicAssets = nitro.options.prerender.ignoreUnprefixedPublicAssets ? new Set(await scanUnprefixedPublicAssets(nitro)) : /* @__PURE__ */ new Set();
+  const canPrerender = (route = "/") => {
+    if (generatedRoutes.has(route) || skippedRoutes.has(route)) {
+      return false;
+    }
+    for (const pattern of nitro.options.prerender.ignore) {
+      if (matchesIgnorePattern(route, pattern)) {
+        return false;
+      }
+    }
+    if (publicAssetBases.some((base) => route.startsWith(base))) {
+      return false;
+    }
+    if (scannedPublicAssets.has(route)) {
+      return false;
+    }
+    if (_getRouteRules(route).prerender === false) {
+      return false;
+    }
+    return true;
+  };
+  const canWriteToDisk = (route) => {
+    if (route.route.includes("?")) {
+      return false;
+    }
+    const FS_MAX_SEGMENT = 255;
+    const FS_MAX_PATH = 1024;
+    const FS_MAX_PATH_PUBLIC_HTML = FS_MAX_PATH - (nitro.options.output.publicDir.length + 10);
+    if ((route.route.length >= FS_MAX_PATH_PUBLIC_HTML || route.route.split("/").some((s) => s.length > FS_MAX_SEGMENT)) && !displayedLengthWarns.has(route)) {
+      displayedLengthWarns.add(route);
+      const _route = route.route.slice(0, 60) + "...";
+      if (route.route.length >= FS_MAX_PATH_PUBLIC_HTML) {
+        nitro.logger.warn(
+          `Prerendering long route "${_route}" (${route.route.length}) can cause filesystem issues since it exceeds ${FS_MAX_PATH_PUBLIC_HTML}-character limit when writing to \`${nitro.options.output.publicDir}\`.`
+        );
+      } else {
+        nitro.logger.warn(
+          `Skipping prerender of the route "${_route}" since it exceeds the ${FS_MAX_SEGMENT}-character limit in one of the path segments and can cause filesystem issues.`
+        );
+        return false;
+      }
+    }
+    return true;
+  };
+  const generateRoute = async (route) => {
+    const start = Date.now();
+    route = decodeURI(route);
+    if (!canPrerender(route)) {
+      skippedRoutes.add(route);
+      return;
+    }
+    generatedRoutes.add(route);
+    const _route = { route };
+    const encodedRoute = encodeURI(route);
+    const res = await appFetch(withBase(encodedRoute, nitro.options.baseURL), {
+      headers: [["x-nitro-prerender", encodedRoute]]
+      // TODO
+      // retry: nitro.options.prerender.retry,
+      // retryDelay: nitro.options.prerender.retryDelay,
+    });
+    let dataBuff = Buffer.from(await res.arrayBuffer());
+    Object.defineProperty(_route, "contents", {
+      get: () => {
+        return dataBuff ? dataBuff.toString("utf8") : void 0;
+      },
+      set(value) {
+        if (dataBuff) {
+          dataBuff = Buffer.from(value);
+        }
+      }
+    });
+    Object.defineProperty(_route, "data", {
+      get: () => {
+        return dataBuff ? dataBuff.buffer : void 0;
+      },
+      set(value) {
+        if (dataBuff) {
+          dataBuff = Buffer.from(value);
+        }
+      }
+    });
+    const redirectCodes = [301, 302, 303, 304, 307, 308];
+    if (![200, ...redirectCodes].includes(res.status)) {
+      _route.error = new Error(`[${res.status}] ${res.statusText}`);
+      _route.error.status = res.status;
+      _route.error.statusText = res.statusText;
+    }
+    _route.generateTimeMS = Date.now() - start;
+    const contentType = res.headers.get("content-type") || "";
+    const isImplicitHTML = !route.endsWith(".html") && contentType.includes("html") && !JsonSigRx.test(dataBuff.subarray(0, 32).toString("utf8"));
+    const routeWithIndex = route.endsWith("/") ? route + "index" : route;
+    const htmlPath = route.endsWith("/") || nitro.options.prerender.autoSubfolderIndex ? joinURL(route, "index.html") : route + ".html";
+    _route.fileName = withoutBase(
+      isImplicitHTML ? htmlPath : routeWithIndex,
+      nitro.options.baseURL
+    );
+    const inferredContentType = mime.getType(_route.fileName) || "text/plain";
+    _route.contentType = contentType || inferredContentType;
+    await nitro.hooks.callHook("prerender:generate", _route, nitro);
+    if (_route.contentType !== inferredContentType) {
+      nitro._prerenderMeta[_route.fileName] ||= {};
+      nitro._prerenderMeta[_route.fileName].contentType = _route.contentType;
+    }
+    if (_route.error) {
+      failedRoutes.add(_route);
+    }
+    if (_route.skip || _route.error) {
+      await nitro.hooks.callHook("prerender:route", _route);
+      nitro.logger.log(formatPrerenderRoute(_route));
+      dataBuff = void 0;
+      return _route;
+    }
+    if (canWriteToDisk(_route)) {
+      const filePath = join(nitro.options.output.publicDir, _route.fileName);
+      await writeFile(filePath, dataBuff);
+      nitro._prerenderedRoutes.push(_route);
+    } else {
+      _route.skip = true;
+    }
+    if (!_route.error && (isImplicitHTML || route.endsWith(".html"))) {
+      const extractedLinks = await extractLinks(
+        dataBuff.toString("utf8"),
+        route,
+        res,
+        nitro.options.prerender.crawlLinks
+      );
+      for (const _link of extractedLinks) {
+        if (canPrerender(_link)) {
+          routes.add(_link);
+        }
+      }
+    }
+    await nitro.hooks.callHook("prerender:route", _route);
+    nitro.logger.log(formatPrerenderRoute(_route));
+    dataBuff = void 0;
+    return _route;
+  };
+  nitro.logger.info(
+    nitro.options.prerender.crawlLinks ? `Prerendering ${routes.size} initial routes with crawler` : `Prerendering ${routes.size} routes`
+  );
+  await runParallel(routes, generateRoute, {
+    concurrency: nitro.options.prerender.concurrency,
+    interval: nitro.options.prerender.interval
+  });
+  await closePrerenderer();
+  await nitro.hooks.callHook("prerender:done", {
+    prerenderedRoutes: nitro._prerenderedRoutes,
+    failedRoutes: [...failedRoutes]
+  });
+  if (nitro.options.prerender.failOnError && failedRoutes.size > 0) {
+    nitro.logger.log("\nErrors prerendering:");
+    for (const route of failedRoutes) {
+      const parents = linkParents.get(route.route);
+      parents?.size ? `
+${[...parents.values()].map((link) => colors.gray(`  \u2502 \u2514\u2500\u2500 Linked from ${link}`)).join("\n")}` : "";
+      nitro.logger.log(formatPrerenderRoute(route));
+    }
+    nitro.logger.log("");
+    throw new Error("Exiting due to prerender errors.");
+  }
+  const prerenderTimeInMs = Date.now() - prerenderStartTime;
+  nitro.logger.info(
+    `Prerendered ${nitro._prerenderedRoutes.length} routes in ${prerenderTimeInMs / 1e3} seconds`
+  );
+  if (nitro.options.compressPublicAssets) {
+    await compressPublicAssets(nitro);
+  }
+}
+
+function createHTTPProxy(defaults = {}) {
+  const proxy = createProxyServer(defaults);
+  proxy.on("proxyReq", (proxyReq, req) => {
+    if (!proxyReq.hasHeader("x-forwarded-for")) {
+      const address = req.socket.remoteAddress;
+      if (address) {
+        proxyReq.appendHeader("x-forwarded-for", address);
+      }
+    }
+    if (!proxyReq.hasHeader("x-forwarded-port")) {
+      const localPort = req?.socket?.localPort;
+      if (localPort) {
+        proxyReq.setHeader("x-forwarded-port", req.socket.localPort);
+      }
+    }
+    if (!proxyReq.hasHeader("x-forwarded-Proto")) {
+      const encrypted = req?.connection?.encrypted;
+      proxyReq.setHeader("x-forwarded-proto", encrypted ? "https" : "http");
+    }
+  });
+  return {
+    proxy,
+    async handleEvent(event, opts) {
+      try {
+        return await fromNodeHandler(
+          (req, res) => proxy.web(req, res, opts)
+        )(event);
+      } catch (error) {
+        event.res.headers.set("refresh", "3");
+        throw new HTTPError({
+          status: 503,
+          message: "Dev server is unavailable.",
+          cause: error
+        });
+      }
+    }
+  };
+}
+function fetchAddress(addr, input, inputInit) {
+  let url;
+  let init;
+  if (input instanceof Request) {
+    url = new URL(input.url);
+    init = {
+      method: input.method,
+      headers: input.headers,
+      body: input.body,
+      ...inputInit
+    };
+  } else {
+    url = new URL(input);
+    init = inputInit;
+  }
+  init = {
+    duplex: "half",
+    redirect: "manual",
+    ...init
+  };
+  if (addr.socketPath) {
+    url.protocol = "http:";
+    return fetch(url, {
+      ...init,
+      ...fetchSocketOptions(addr.socketPath)
+    });
+  }
+  const origin = `http://${addr.host}${addr.port ? `:${addr.port}` : ""}`;
+  const outURL = new URL(url.pathname + url.search, origin);
+  return fetch(outURL, init);
+}
+function fetchSocketOptions(socketPath) {
+  if ("Bun" in globalThis) {
+    return { unix: socketPath };
+  }
+  if ("Deno" in globalThis) {
+    return {
+      // @ts-ignore
+      client: Deno.createHttpClient({
+        // @ts-ignore Missing types?
+        transport: "unix",
+        path: socketPath
+      })
+    };
+  }
+  return {
+    dispatcher: new Agent({ connect: { socketPath } })
+  };
+}
+
+class NodeDevWorker {
+  closed = false;
+  #name;
+  #entry;
+  #data;
+  #hooks;
+  #worker;
+  #address;
+  #proxy;
+  #messageListeners;
+  constructor(opts) {
+    this.#name = opts.name;
+    this.#entry = opts.entry;
+    this.#data = opts.data;
+    this.#hooks = opts.hooks;
+    this.#proxy = createHTTPProxy();
+    this.#messageListeners = /* @__PURE__ */ new Set();
+    this.#initWorker();
+  }
+  get ready() {
+    return Boolean(
+      !this.closed && this.#address && this.#proxy && this.#worker
+    );
+  }
+  // #region Public methods
+  async fetch(input, init) {
+    for (let i = 0; i < 5 && !(this.#address && this.#proxy); i++) {
+      await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
+    }
+    if (!(this.#address && this.#proxy)) {
+      return new Response("Dev worker is unavailable", { status: 503 });
+    }
+    return fetchAddress(this.#address, input, init);
+  }
+  upgrade(req, socket, head) {
+    if (!this.ready) {
+      return;
+    }
+    return this.#proxy.proxy.ws(
+      req,
+      socket,
+      { target: this.#address, xfwd: true },
+      head
+    );
+  }
+  sendMessage(message) {
+    if (!this.#worker) {
+      throw new Error(
+        "Dev worker should be initialized before sending messages."
+      );
+    }
+    this.#worker.postMessage(message);
+  }
+  onMessage(listener) {
+    this.#messageListeners.add(listener);
+  }
+  offMessage(listener) {
+    this.#messageListeners.delete(listener);
+  }
+  async close(cause) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.#hooks.onClose?.(this, cause);
+    this.#hooks = {};
+    const onError = (error) => consola.error(error);
+    await this.#closeWorker().catch(onError);
+    await this.#closeProxy().catch(onError);
+    await this.#closeSocket().catch(onError);
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    const status = this.closed ? "closed" : this.ready ? "ready" : "pending";
+    return `NodeDevWorker#${this.#name}(${status})`;
+  }
+  // #endregion
+  // #region Private methods
+  #initWorker() {
+    if (!existsSync(this.#entry)) {
+      this.close(`worker entry not found in "${this.#entry}".`);
+      return;
+    }
+    const worker = new Worker(this.#entry, {
+      env: {
+        ...process.env
+      },
+      workerData: {
+        name: this.#name,
+        ...this.#data
+      }
+    });
+    worker.once("exit", (code) => {
+      worker._exitCode = code;
+      this.close(`worker exited with code ${code}`);
+    });
+    worker.once("error", (error) => {
+      consola.error(`Worker error:`, error);
+      this.close(error);
+    });
+    worker.on("message", (message) => {
+      if (message?.address) {
+        this.#address = message.address;
+        this.#hooks.onReady?.(this, this.#address);
+      }
+      for (const listener of this.#messageListeners) {
+        listener(message);
+      }
+    });
+    this.#worker = worker;
+  }
+  async #closeProxy() {
+    this.#proxy?.proxy?.close(() => {
+    });
+    this.#proxy = void 0;
+  }
+  async #closeSocket() {
+    const socketPath = this.#address?.socketPath;
+    if (socketPath && socketPath[0] !== "\0" && !socketPath.startsWith(String.raw`\\.\pipe`)) {
+      await rm(socketPath).catch(() => {
+      });
+    }
+    this.#address = void 0;
+  }
+  async #closeWorker() {
+    if (!this.#worker) {
+      return;
+    }
+    this.#worker.postMessage({ event: "shutdown" });
+    if (!this.#worker._exitCode && !isTest && !isCI) {
+      await new Promise((resolve) => {
+        const gracefulShutdownTimeoutMs = Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 5e3;
+        const timeout = setTimeout(() => {
+          if (process.env.DEBUG) {
+            consola.warn(`force closing dev worker...`);
+          }
+        }, gracefulShutdownTimeoutMs);
+        this.#worker?.on("message", (message) => {
+          if (message.event === "exit") {
+            clearTimeout(timeout);
+            resolve();
+          }
+        });
+      });
+    }
+    this.#worker.removeAllListeners();
+    await this.#worker.terminate().catch((error) => {
+      consola.error(error);
+    });
+    this.#worker = void 0;
+  }
+  // #endregion
+}
+
+function createVFSHandler(nitro) {
+  return defineHandler(async (event) => {
+    const { socket } = event.runtime?.node?.req || {};
+    const isUnixSocket = (
+      // No network addresses
+      !socket?.remoteAddress && !socket?.localAddress && // Empty address object
+      Object.keys(socket?.address?.() || {}).length === 0 && // Socket is readable/writable but has no port info
+      socket?.readable && socket?.writable && !socket?.remotePort
+    );
+    const ip = getRequestIP(event, { xForwardedFor: isUnixSocket });
+    const isLocalRequest = ip && /^::1$|^127\.\d+\.\d+\.\d+$/.test(ip);
+    if (!isLocalRequest) {
+      throw new HTTPError({
+        statusText: `Forbidden IP: "${ip || "?"}"`,
+        status: 403
+      });
+    }
+    const vfsEntries = {
+      ...nitro.vfs,
+      ...nitro.options.virtual
+    };
+    const url = event.context.params?._ || "";
+    const isJson = url.endsWith(".json") || event.req.headers.get("accept")?.includes("application/json");
+    const id = decodeURIComponent(url.replace(/^(\.json)?\/?/, "") || "");
+    if (id && !(id in vfsEntries)) {
+      throw new HTTPError({ message: "File not found", status: 404 });
+    }
+    let content = id ? vfsEntries[id] : void 0;
+    if (typeof content === "function") {
+      content = await content();
+    }
+    if (isJson) {
+      return {
+        rootDir: nitro.options.rootDir,
+        entries: Object.keys(vfsEntries).map((id2) => ({
+          id: id2,
+          path: "/_vfs.json/" + encodeURIComponent(id2)
+        })),
+        current: id ? {
+          id,
+          content
+        } : null
+      };
+    }
+    const directories = { [nitro.options.rootDir]: {} };
+    const fpaths = Object.keys(vfsEntries);
+    for (const item of fpaths) {
+      const segments = item.replace(nitro.options.rootDir, "").split("/").filter(Boolean);
+      let currentDir = item.startsWith(nitro.options.rootDir) ? directories[nitro.options.rootDir] : directories;
+      for (const segment of segments) {
+        if (!currentDir[segment]) {
+          currentDir[segment] = {};
+        }
+        currentDir = currentDir[segment];
+      }
+    }
+    const generateHTML = (directory, path = []) => Object.entries(directory).map(([fname, value = {}]) => {
+      const subpath = [...path, fname];
+      const key = subpath.join("/");
+      const encodedUrl = encodeURIComponent(key);
+      const linkClass = url === `/${encodedUrl}` ? "bg-gray-700 text-white" : "hover:bg-gray-800 text-gray-200";
+      return Object.keys(value).length === 0 ? `
+            <li class="flex flex-nowrap">
+              <a href="/_vfs/${encodedUrl}" class="w-full text-sm px-2 py-1 border-b border-gray-10 ${linkClass}">
+                ${fname}
+              </a>
+            </li>
+            ` : `
+            <li>
+              <details ${url.startsWith(`/${encodedUrl}`) ? "open" : ""}>
+                <summary class="w-full text-sm px-2 py-1 border-b border-gray-10 hover:bg-gray-800 text-gray-200">
+                  ${fname}
+                </summary>
+                <ul class="ml-4">
+                  ${generateHTML(value, subpath)}
+                </ul>
+              </details>
+            </li>
+            `;
+    }).join("");
+    const rootDirectory = directories[nitro.options.rootDir];
+    delete directories[nitro.options.rootDir];
+    const items = generateHTML(rootDirectory, [nitro.options.rootDir]) + generateHTML(directories);
+    const files = `
+      <div class="h-full overflow-auto border-r border-gray:10">
+        <p class="text-white text-bold text-center py-1 opacity-50">Virtual Files</p>
+        <ul class="flex flex-col">${items}</ul>
+      </div>
+      `;
+    const file = id ? editorTemplate({
+      readOnly: true,
+      language: id.endsWith("html") ? "html" : "javascript",
+      theme: "vs-dark",
+      value: content,
+      wordWrap: "wordWrapColumn",
+      wordWrapColumn: 80
+    }) : `
+        <div class="w-full h-full flex opacity-50">
+          <h1 class="text-white m-auto">Select a virtual file to inspect</h1>
+        </div>
+      `;
+    event.res.headers.set("Content-Type", "text/html; charset=utf-8");
+    return (
+      /* html */
+      `
+<!doctype html>
+<html>
+<head>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@unocss/reset/tailwind.min.css" />
+  <link rel="stylesheet" data-name="vs/editor/editor.main" href="${vsUrl}/editor/editor.main.min.css">
+  <script src="https://cdn.jsdelivr.net/npm/@unocss/runtime"><\/script>
+  <style>
+    html {
+      background: #1E1E1E;
+      color: white;
+    }
+    [un-cloak] {
+      display: none;
+    }
+  </style>
+</head>
+<body class="bg-[#1E1E1E]">
+  <div un-cloak class="h-screen grid grid-cols-[300px_1fr]">
+    ${files}
+    ${file}
+  </div>
+</body>
+</html>`
+    );
+  });
+}
+const monacoVersion = "0.30.0";
+const monacoUrl = `https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/${monacoVersion}/min`;
+const vsUrl = `${monacoUrl}/vs`;
+const editorTemplate = (options) => `
+<div id="editor" class="min-h-screen w-full h-full"></div>
+<script src="${vsUrl}/loader.min.js"><\/script>
+<script>
+  require.config({ paths: { vs: '${vsUrl}' } })
+
+  const proxy = URL.createObjectURL(new Blob([\`
+    self.MonacoEnvironment = { baseUrl: '${monacoUrl}' }
+    importScripts('${vsUrl}/base/worker/workerMain.min.js')
+  \`], { type: 'text/javascript' }))
+  window.MonacoEnvironment = { getWorkerUrl: () => proxy }
+
+  setTimeout(() => {
+    require(['vs/editor/editor.main'], function () {
+      monaco.editor.create(document.getElementById('editor'), ${JSON.stringify(
+  options
+)})
+    })
+  }, 0);
+<\/script>
+`;
+
+function defineNitroErrorHandler(handler) {
+  return handler;
+}
+
+const devErrorHandler = defineNitroErrorHandler(
+  async function defaultNitroErrorHandler(error, event) {
+    const res = await defaultHandler(error, event);
+    return new FastResponse(
+      typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2),
+      res
+    );
+  }
+);
+async function defaultHandler(error, event, opts) {
+  const isSensitive = error.unhandled;
+  const status = error.status || 500;
+  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  if (status === 404) {
+    const baseURL = import.meta.baseURL || "/";
+    if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+      const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
+      return {
+        status: 302,
+        statusText: "Found",
+        headers: { location: redirectTo },
+        body: `Redirecting...`
+      };
+    }
+  }
+  await loadStackTrace(error).catch(consola.error);
+  const youch = new Youch();
+  if (isSensitive && !opts?.silent) {
+    const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
+    const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
+    consola.error(
+      `[request error] ${tags} [${event.req.method}] ${url}
+
+`,
+      ansiError
+    );
+  }
+  const useJSON = opts?.json || !event.req.headers.get("accept")?.includes("text/html");
+  const headers = {
+    "content-type": useJSON ? "application/json" : "text/html",
+    // Prevent browser from guessing the MIME types of resources.
+    "x-content-type-options": "nosniff",
+    // Prevent error page from being embedded in an iframe
+    "x-frame-options": "DENY",
+    // Prevent browsers from sending the Referer header
+    "referrer-policy": "no-referrer",
+    // Disable the execution of any js
+    "content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
+  };
+  if (status === 404 || !event.res.headers.has("cache-control")) {
+    headers["cache-control"] = "no-cache";
+  }
+  const body = useJSON ? {
+    error: true,
+    url,
+    status,
+    statusText: error.statusText,
+    message: error.message,
+    data: error.data,
+    stack: error.stack?.split("\n").map((line) => line.trim())
+  } : await youch.toHTML(error, {
+    request: {
+      url: url.href,
+      method: event.req.method,
+      headers: Object.fromEntries(event.req.headers.entries())
+    }
+  });
+  return {
+    status,
+    statusText: error.statusText,
+    headers,
+    body
+  };
+}
+async function loadStackTrace(error) {
+  if (!(error instanceof Error)) {
+    return;
+  }
+  const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
+  const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
+  Object.defineProperty(error, "stack", { value: stack });
+  if (error.cause) {
+    await loadStackTrace(error.cause).catch(consola.error);
+  }
+}
+async function sourceLoader(frame) {
+  if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
+    return;
+  }
+  if (frame.type === "app") {
+    const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {
+    });
+    if (rawSourceMap) {
+      const consumer = await new SourceMapConsumer(rawSourceMap);
+      const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber });
+      if (originalPosition.source && originalPosition.line) {
+        frame.fileName = resolve$1(dirname(frame.fileName), originalPosition.source);
+        frame.lineNumber = originalPosition.line;
+        frame.columnNumber = originalPosition.column || 0;
+      }
+    }
+  }
+  const contents = await readFile(frame.fileName, "utf8").catch(() => {
+  });
+  return contents ? { contents } : void 0;
+}
+function fmtFrame(frame) {
+  if (frame.type === "native") {
+    return frame.raw;
+  }
+  const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
+  return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
+}
+
+class NitroDevApp {
+  nitro;
+  fetch;
+  constructor(nitro, catchAllHandler) {
+    this.nitro = nitro;
+    const app = this.#createApp(catchAllHandler);
+    this.fetch = app.fetch.bind(app);
+  }
+  #createApp(catchAllHandler) {
+    const app = new H3({
+      debug: true,
+      onError: async (error, event) => {
+        const errorHandler = this.nitro.options.devErrorHandler || devErrorHandler;
+        await loadStackTrace(error).catch(() => {
+        });
+        return errorHandler(error, event, {
+          defaultHandler: defaultHandler
+        });
+      }
+    });
+    for (const h of this.nitro.options.devHandlers) {
+      const handler = toEventHandler(h.handler);
+      if (!handler) {
+        this.nitro.logger.warn("Invalid dev handler:", h);
+        continue;
+      }
+      if (h.middleware || !h.route) {
+        if (h.route) {
+          app.use(h.route, handler, { method: h.method });
+        } else {
+          app.use(handler, { method: h.method });
+        }
+      } else {
+        app.on(h.method || "", h.route, handler, { meta: h.meta });
+      }
+    }
+    app.get("/_vfs/**", createVFSHandler(this.nitro));
+    for (const asset of this.nitro.options.publicAssets) {
+      const assetRoute = joinURL(
+        this.nitro.options.runtimeConfig.app.baseURL,
+        asset.baseURL || "/",
+        "**"
+      );
+      let handler = fromNodeHandler(
+        // @ts-expect-error (HTTP2 types)
+        serveStatic(asset.dir, { dotfiles: "allow" })
+      );
+      if (asset.baseURL?.length || 0 > 1) {
+        handler = withBase$1(asset.baseURL, handler);
+      }
+      app.use(assetRoute, handler);
+    }
+    const routes = Object.keys(this.nitro.options.devProxy).sort().reverse();
+    for (const route of routes) {
+      let opts = this.nitro.options.devProxy[route];
+      if (typeof opts === "string") {
+        opts = { target: opts };
+      }
+      const proxy = createHTTPProxy(opts);
+      app.all(route, proxy.handleEvent);
+    }
+    if (catchAllHandler) {
+      app.all("/**", catchAllHandler);
+    }
+    return app;
+  }
+}
+
+function createDevServer(nitro) {
+  return new NitroDevServer(nitro);
+}
+class NitroDevServer extends NitroDevApp {
+  #entry;
+  #workerData = {};
+  #listeners = [];
+  #watcher;
+  #workers = [];
+  #workerIdCtr = 0;
+  #workerError;
+  #building = true;
+  // Assume initial build will start soon
+  #buildError;
+  #messageListeners = /* @__PURE__ */ new Set();
+  constructor(nitro) {
+    super(nitro, async (event) => {
+      const worker = await this.#getWorker();
+      if (!worker) {
+        return this.#generateError();
+      }
+      return worker.fetch(event.req);
+    });
+    for (const key of Object.getOwnPropertyNames(NitroDevServer.prototype)) {
+      const value = this[key];
+      if (typeof value === "function" && key !== "constructor") {
+        this[key] = value.bind(this);
+      }
+    }
+    this.#entry = resolve(
+      nitro.options.output.dir,
+      nitro.options.output.serverDir,
+      "index.mjs"
+    );
+    nitro.hooks.hook("close", () => this.close());
+    nitro.hooks.hook("dev:start", () => {
+      this.#building = true;
+      this.#buildError = void 0;
+    });
+    nitro.hooks.hook("dev:reload", (payload) => {
+      this.#buildError = void 0;
+      this.#building = false;
+      if (payload?.entry) {
+        this.#entry = payload.entry;
+      }
+      if (payload?.workerData) {
+        this.#workerData = payload.workerData;
+      }
+      this.reload();
+    });
+    nitro.hooks.hook("dev:error", (cause) => {
+      this.#buildError = cause;
+      this.#building = false;
+      for (const worker of this.#workers) {
+        worker.close();
+      }
+    });
+    if (nitro.options.devServer.watch.length > 0) {
+      const debouncedReload = debounce(() => this.reload());
+      this.#watcher = watch(
+        nitro.options.devServer.watch,
+        nitro.options.watchOptions
+      );
+      this.#watcher.on("add", debouncedReload).on("change", debouncedReload);
+    }
+  }
+  // #region Public Methods
+  async upgrade(req, socket, head) {
+    const worker = await this.#getWorker();
+    if (!worker) {
+      throw new HTTPError({
+        status: 503,
+        statusText: "No worker available."
+      });
+    }
+    return worker.upgrade(req, socket, head);
+  }
+  listen(opts) {
+    const server = serve({
+      ...opts,
+      fetch: this.fetch
+    });
+    this.#listeners.push(server);
+    if (server.node?.server) {
+      server.node.server.on(
+        "upgrade",
+        (req, sock, head) => this.upgrade(req, sock, head)
+      );
+    }
+    return server;
+  }
+  async close() {
+    await Promise.all(
+      [
+        Promise.all(this.#listeners.map((l) => l.close())).then(() => {
+          this.#listeners = [];
+        }),
+        Promise.all(this.#workers.map((w) => w.close())).then(() => {
+          this.#workers = [];
+        }),
+        Promise.resolve(this.#watcher?.close()).then(() => {
+          this.#watcher = void 0;
+        })
+      ].map(
+        (p) => p.catch((error) => {
+          consola.error(error);
+        })
+      )
+    );
+  }
+  reload() {
+    for (const worker2 of this.#workers) {
+      worker2.close();
+    }
+    const worker = new NodeDevWorker({
+      name: `Nitro_${this.#workerIdCtr++}`,
+      entry: this.#entry,
+      data: {
+        ...this.#workerData,
+        globals: {
+          __NITRO_RUNTIME_CONFIG__: this.nitro.options.runtimeConfig,
+          ...this.#workerData.globals
+        }
+      },
+      hooks: {
+        onClose: (worker2, cause) => {
+          this.#workerError = cause;
+          const index = this.#workers.indexOf(worker2);
+          if (index !== -1) {
+            this.#workers.splice(index, 1);
+          }
+        },
+        onReady: (worker2, addr) => {
+          this.#writeBuildInfo(worker2, addr);
+        }
+      }
+    });
+    if (!worker.closed) {
+      for (const listener of this.#messageListeners) {
+        worker.onMessage(listener);
+      }
+      this.#workers.unshift(worker);
+    }
+  }
+  sendMessage(message) {
+    for (const worker of this.#workers) {
+      if (!worker.closed) {
+        worker.sendMessage(message);
+      }
+    }
+  }
+  onMessage(listener) {
+    this.#messageListeners.add(listener);
+    for (const worker of this.#workers) {
+      worker.onMessage(listener);
+    }
+  }
+  offMessage(listener) {
+    this.#messageListeners.delete(listener);
+    for (const worker of this.#workers) {
+      worker.offMessage(listener);
+    }
+  }
+  // #endregion
+  // #region Private Methods
+  #writeBuildInfo(_worker, addr) {
+    const buildInfoPath = resolve(this.nitro.options.buildDir, "nitro.json");
+    const buildInfo = {
+      date: (/* @__PURE__ */ new Date()).toJSON(),
+      preset: this.nitro.options.preset,
+      framework: this.nitro.options.framework,
+      versions: {
+        nitro: version
+      },
+      dev: {
+        pid: process.pid,
+        workerAddress: addr
+      }
+    };
+    writeFile$1(buildInfoPath, JSON.stringify(buildInfo, null, 2)).catch(
+      (error) => {
+        consola.error(error);
+      }
+    );
+  }
+  async #getWorker() {
+    let retry = 0;
+    const maxRetries = isTest || isCI ? 100 : 10;
+    while (this.#building || ++retry < maxRetries) {
+      if ((this.#workers.length === 0 || this.#buildError) && !this.#building) {
+        return;
+      }
+      const activeWorker = this.#workers.find((w) => w.ready);
+      if (activeWorker) {
+        return activeWorker;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 600));
+    }
+  }
+  #generateError() {
+    const error = this.#buildError || this.#workerError;
+    if (error) {
+      try {
+        error.unhandled = false;
+        let id = error.id || error.path;
+        if (id) {
+          const cause = error.errors?.[0];
+          const loc = error.location || error.loc || cause?.location || cause?.loc;
+          if (loc) {
+            id += `:${loc.line}:${loc.column}`;
+          }
+          error.stack = (error.stack || "").replace(
+            /(^\s*at\s+.+)/m,
+            `    at ${id}
+$1`
+          );
+        }
+      } catch {
+      }
+      return new HTTPError(error);
+    }
+    return new Response(
+      JSON.stringify(
+        {
+          error: "Dev server is unavailable.",
+          hint: "Please reload the page and check the console for errors if the issue persists."
+        },
+        null,
+        2
+      ),
+      {
+        status: 503,
+        statusText: "Dev server is unavailable",
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store",
+          Refresh: "3"
+        }
+      }
+    );
+  }
+  // #endregion
+}
+
+const getViteRollupConfig = (ctx) => {
+  const nitro = ctx.nitro;
+  const base = baseBuildConfig(nitro);
+  const chunkNamePrefixes = [
+    [nitro.options.buildDir, "build"],
+    [base.buildServerDir, "app"],
+    [runtimeDir, "nitro"],
+    [base.presetsDir, "nitro"],
+    ["\0nitro-wasm:", "wasm"],
+    ["\0", "virtual"]
+  ];
+  function getChunkGroup(id) {
+    if (id.startsWith(runtimeDir) || id.startsWith(base.presetsDir)) {
+      return "nitro";
+    }
+  }
+  let config = {
+    input: nitro.options.entry,
+    external: [...base.env.external],
+    plugins: [
+      ctx.pluginConfig.experimental?.virtualBundle && virtualBundlePlugin(ctx._serviceBundles),
+      ...baseBuildPlugins(nitro, base),
+      alias({ entries: base.aliases }),
+      replace({
+        delimiters: base.replaceDelimiters,
+        preventAssignment: true,
+        values: base.replacements
+      }),
+      inject(base.env.inject)
+    ].filter(Boolean),
+    treeshake: {
+      moduleSideEffects(id) {
+        const normalizedId = normalize(id);
+        const idWithoutNodeModules = normalizedId.split("node_modules/").pop();
+        if (!idWithoutNodeModules) {
+          return false;
+        }
+        if (normalizedId.startsWith(runtimeDir) || idWithoutNodeModules.startsWith(runtimeDir)) {
+          return true;
+        }
+        return nitro.options.moduleSideEffects.some(
+          (m) => normalizedId.startsWith(m) || idWithoutNodeModules.startsWith(m)
+        );
+      }
+    },
+    output: {
+      dir: nitro.options.output.serverDir,
+      entryFileNames: "index.mjs",
+      chunkFileNames(chunk) {
+        const id = normalize(chunk.moduleIds.at(-1) || "");
+        for (const [dir, name] of chunkNamePrefixes) {
+          if (id.startsWith(dir)) {
+            return `chunks/${name}/[name].mjs`;
+          }
+        }
+        const routeHandler = nitro.options.handlers.find(
+          (h) => id.startsWith(h.handler)
+        ) || nitro.scannedHandlers.find((h) => id.startsWith(h.handler));
+        if (routeHandler?.route) {
+          const path = routeHandler.route.replace(/:([^/]+)/g, "_$1").replace(/\/[^/]+$/g, "") || "/";
+          return `chunks/routes/${path}/[name].mjs`.replace(/\/+/g, "/");
+        }
+        const taskHandler = Object.entries(nitro.options.tasks).find(
+          ([_, task]) => task.handler === id
+        );
+        if (taskHandler) {
+          return `chunks/tasks/[name].mjs`;
+        }
+        return `chunks/_/[name].mjs`;
+      },
+      manualChunks(id) {
+        return getChunkGroup(id);
+      },
+      inlineDynamicImports: nitro.options.inlineDynamicImports,
+      format: "esm",
+      exports: "auto",
+      intro: "",
+      outro: "",
+      generatedCode: {
+        constBindings: true
+      },
+      sanitizeFileName: sanitizeFilePath,
+      sourcemapExcludeSources: true,
+      sourcemapIgnoreList(relativePath) {
+        return relativePath.includes("node_modules");
+      }
+    }
+  };
+  config = defu(nitro.options.rollupConfig, config);
+  if (config.output.inlineDynamicImports) {
+    delete config.output.manualChunks;
+  }
+  return { config, base };
+};
+function virtualBundlePlugin(bundles) {
+  let _modules = null;
+  const getModules = () => {
+    if (_modules) {
+      return _modules;
+    }
+    _modules = /* @__PURE__ */ new Map();
+    for (const bundle of Object.values(bundles)) {
+      for (const [fileName, content] of Object.entries(bundle)) {
+        if (content.type === "chunk") {
+          const virtualModule = {
+            code: content.code,
+            map: null
+          };
+          const maybeMap = bundle[`${fileName}.map`];
+          if (maybeMap && maybeMap.type === "asset") {
+            virtualModule.map = maybeMap.source;
+          }
+          _modules.set(fileName, virtualModule);
+          _modules.set(resolve(fileName), virtualModule);
+        }
+      }
+    }
+    return _modules;
+  };
+  return {
+    name: "virtual-bundle",
+    resolveId(id, importer) {
+      const modules = getModules();
+      if (modules.has(id)) {
+        return resolve(id);
+      }
+      if (importer) {
+        const resolved = resolve(dirname$1(importer), id);
+        if (modules.has(resolved)) {
+          return resolved;
+        }
+      }
+      return null;
+    },
+    load(id) {
+      const modules = getModules();
+      const m = modules.get(id);
+      if (!m) {
+        return null;
+      }
+      return m;
+    }
+  };
+}
+
+const BuilderNames = {
+  nitro: colors.magenta("Nitro"),
+  client: colors.green("Client"),
+  ssr: colors.blue("SSR")
+};
+async function buildEnvironments(ctx, builder) {
+  const nitro = ctx.nitro;
+  for (const [envName, env] of Object.entries(builder.environments)) {
+    const fmtName = BuilderNames[envName] || (envName.length <= 3 ? envName.toUpperCase() : envName[0].toUpperCase() + envName.slice(1));
+    if (envName === "nitro" || !env.config.build.rollupOptions.input || env.isBuilt) {
+      if (!["nitro", "ssr", "client"].includes(envName)) {
+        nitro.logger.info(
+          env.isBuilt ? `Skipping ${fmtName} (already built)` : `Skipping ${fmtName} (no input defined)`
+        );
+      }
+      continue;
+    }
+    if (!isTest && !isCI) console.log();
+    nitro.logger.start(`Building [${fmtName}]`);
+    await builder.build(env);
+  }
+  const nitroOptions = ctx.nitro.options;
+  const clientInput = builder.environments.client?.config?.build?.rollupOptions?.input;
+  if (nitroOptions.renderer?.template && nitroOptions.renderer?.template === clientInput) {
+    const outputPath = resolve(
+      nitroOptions.output.publicDir,
+      basename(clientInput)
+    );
+    if (existsSync(outputPath)) {
+      const html = await readFile(outputPath, "utf8").then(
+        (r) => r.replace(
+          "<!--ssr-outlet-->",
+          `{{{ fetch($REQUEST, { viteEnv: "ssr" }) }}}`
+        )
+      );
+      await rm(outputPath);
+      const tmp = resolve(nitroOptions.buildDir, "vite/index.html");
+      await mkdir(dirname$1(tmp), { recursive: true });
+      await writeFile$1(tmp, html, "utf8");
+      nitroOptions.renderer.template = tmp;
+    }
+  }
+  await builder.writeAssetsManifest?.();
+  if (!isTest && !isCI) console.log();
+  const buildInfo = [
+    ["preset", nitro.options.preset],
+    ["compatibility", formatCompatibilityDate(nitro.options.compatibilityDate)]
+  ].filter((e) => e[1]);
+  nitro.logger.start(
+    `Building [${BuilderNames.nitro}] ${colors.dim(`(${buildInfo.map(([k, v]) => `${k}: \`${v}\``).join(", ")})`)}`
+  );
+  await copyPublicAssets(nitro);
+  await builder.build(builder.environments.nitro);
+  await nitro.close();
+  await nitro.hooks.callHook("compiled", nitro);
+  await writeBuildInfo(nitro);
+  const rOutput = relative(process.cwd(), nitro.options.output.dir);
+  const rewriteRelativePaths = (input) => {
+    return input.replace(/([\s:])\.\/(\S*)/g, `$1${rOutput}/$2`);
+  };
+  if (!isTest && !isCI) console.log();
+  if (nitro.options.commands.preview) {
+    nitro.logger.success(
+      `You can preview this build using \`${rewriteRelativePaths(
+        nitro.options.commands.preview
+      )}\``
+    );
+  }
+  if (nitro.options.commands.deploy) {
+    nitro.logger.success(
+      `You can deploy this build using \`${rewriteRelativePaths(
+        nitro.options.commands.deploy
+      )}\``
+    );
+  }
+}
+function prodSetup(ctx) {
+  const services = ctx.pluginConfig.services || {};
+  const serviceNames = Object.keys(services);
+  const serviceEntries = serviceNames.map((name) => {
+    let entry;
+    if (ctx.pluginConfig.experimental?.virtualBundle) {
+      entry = ctx._entryPoints[name];
+    } else {
+      entry = resolve(
+        ctx.nitro.options.buildDir,
+        "vite/services",
+        name,
+        ctx._entryPoints[name]
+      );
+    }
+    return [name, entry];
+  });
+  return (
+    /* js */
+    `
+import { setupVite } from "${resolve(runtimeDir, "internal/vite/prod-setup.mjs")}";
+
+const manifest = ${JSON.stringify(ctx._manifest || {})};
+
+function lazyService(loader) {
+  let promise, mod
+  return {
+    fetch(req) {
+      if (mod) { return mod.fetch(req) }
+      if (!promise) {
+        promise = loader().then(_mod => (mod = _mod.default || _mod))
+      }
+      return promise.then(mod => mod.fetch(req))
+    }
+  }
+}
+
+const services = {
+${serviceEntries.map(
+      ([name, entry]) => (
+        /* js */
+        `[${JSON.stringify(name)}]: lazyService(() => import(${JSON.stringify(entry)}))`
+      )
+    ).join(",\n")}
+};
+
+setupVite({ manifest, services });
+  `
+  );
+}
+
+function createFetchableDevEnvironment(name, config, devServer, entry) {
+  const transport = createTransport(name, devServer);
+  const context = { hot: true, transport };
+  return new FetchableDevEnvironment(name, config, context, devServer, entry);
+}
+class FetchableDevEnvironment extends DevEnvironment {
+  devServer;
+  constructor(name, config, context, devServer, entry) {
+    super(name, config, context);
+    this.devServer = devServer;
+    this.devServer.sendMessage({
+      type: "custom",
+      event: "nitro:vite-env",
+      data: { name, entry }
+    });
+  }
+  async dispatchFetch(request) {
+    return this.devServer.fetch(request);
+  }
+  async init(...args) {
+    await this.devServer.init?.();
+    return super.init(...args);
+  }
+}
+function createTransport(name, hooks) {
+  const listeners = /* @__PURE__ */ new WeakMap();
+  return {
+    send: (data) => hooks.sendMessage({ ...data, viteEnv: name }),
+    on: (event, handler) => {
+      if (event === "connection") return;
+      const listener = (value) => {
+        if (value?.type === "custom" && value.event === event && value.viteEnv === name) {
+          handler(value.data, {
+            send: (payload) => hooks.sendMessage({ ...payload, viteEnv: name })
+          });
+        }
+      };
+      listeners.set(handler, listener);
+      hooks.onMessage(listener);
+    },
+    off: (event, handler) => {
+      if (event === "connection") return;
+      const listener = listeners.get(handler);
+      if (listener) {
+        hooks.offMessage(listener);
+        listeners.delete(handler);
+      }
+    }
+  };
+}
+async function configureViteDevServer(ctx, server) {
+  const nitro = ctx.nitro;
+  const nitroEnv = server.environments.nitro;
+  const nitroConfigFile = nitro.options._c12.configFile;
+  if (nitroConfigFile) {
+    server.config.configFileDependencies.push(nitroConfigFile);
+  }
+  const reload = debounce(async () => {
+    await scanHandlers(nitro);
+    nitro.routing.sync();
+    nitroEnv.moduleGraph.invalidateAll();
+    nitroEnv.hot.send({ type: "full-reload" });
+  });
+  const scanDirs = nitro.options.scanDirs.flatMap((dir) => [
+    join(dir, nitro.options.apiDir || "api"),
+    join(dir, nitro.options.routesDir || "routes"),
+    join(dir, "middleware"),
+    join(dir, "plugins"),
+    join(dir, "modules")
+  ]);
+  const watchReloadEvents = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir"]);
+  const scanDirsWatcher = watch(scanDirs, {
+    ignoreInitial: true
+  }).on("all", (event, path, stat) => {
+    if (watchReloadEvents.has(event)) {
+      reload();
+    }
+  });
+  const srcDirWatcher = watch$1(
+    nitro.options.srcDir,
+    { persistent: false },
+    (_event, filename) => {
+      if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) {
+        reload();
+      }
+    }
+  );
+  nitro.hooks.hook("close", () => {
+    scanDirsWatcher.close();
+    srcDirWatcher.close();
+  });
+  const hostIPC = {
+    async transformHTML(html) {
+      return server.transformIndexHtml("/", html).then(
+        (r) => r.replace(
+          "<!--ssr-outlet-->",
+          `{{{ fetch($REQUEST, { viteEnv: "ssr" }) }}}`
+        )
+      );
+    }
+  };
+  nitroEnv.devServer.onMessage(async (payload) => {
+    if (payload.type === "custom" && payload.event === "nitro:vite-invoke") {
+      const methodName = payload.data.name;
+      const res = await hostIPC[methodName](payload.data.data).then((data) => ({ data })).catch((error) => ({ error }));
+      nitroEnv.devServer.sendMessage({
+        type: "custom",
+        event: "nitro:vite-invoke-response",
+        data: { id: payload.data.id, data: res }
+      });
+    }
+  });
+  const nitroDevMiddleware = async (nodeReq, nodeRes, next) => {
+    if (/^\/@(?:vite|fs|id)\//.test(nodeReq.url) || nodeReq._nitroHandled) {
+      return next();
+    }
+    nodeReq._nitroHandled = true;
+    const req = new NodeRequest({ req: nodeReq, res: nodeRes });
+    const devAppRes = await ctx.devApp.fetch(req);
+    if (nodeRes.writableEnded || nodeRes.headersSent) {
+      return;
+    }
+    if (devAppRes.status !== 404) {
+      return await sendNodeResponse(nodeRes, devAppRes);
+    }
+    const envRes = await nitroEnv.dispatchFetch(req);
+    if (nodeRes.writableEnded || nodeRes.headersSent) {
+      return;
+    }
+    if (envRes.status !== 404) {
+      return await sendNodeResponse(nodeRes, envRes);
+    }
+    return next();
+  };
+  server.middlewares.use(function nitroDevMiddlewarePre(req, res, next) {
+    const fetchDest = req.headers["sec-fetch-dest"];
+    if (fetchDest) {
+      res.setHeader("vary", "sec-fetch-dest");
+    }
+    const ext = (req.url || "").match(/\.([a-z0-9]+)(?:[?#]|$)/i)?.[1] || "";
+    if (!ext && (!fetchDest || /^(document|iframe|frame|empty)$/.test(fetchDest))) {
+      nitroDevMiddleware(req, res, next);
+    } else {
+      next();
+    }
+  });
+  return () => {
+    server.middlewares.use(nitroDevMiddleware);
+  };
+}
+
+function createDevWorker(ctx) {
+  return new NodeDevWorker({
+    name: "nitro-vite",
+    entry: resolve$1(runtimeDir, "internal/vite/dev-worker.mjs"),
+    hooks: {},
+    data: {
+      server: true,
+      globals: {
+        __NITRO_RUNTIME_CONFIG__: ctx.nitro.options.runtimeConfig
+      }
+    }
+  });
+}
+function createNitroEnvironment(ctx) {
+  return {
+    consumer: "server",
+    build: {
+      rollupOptions: ctx.rollupConfig.config,
+      minify: ctx.nitro.options.minify,
+      emptyOutDir: false,
+      commonjsOptions: {
+        strictRequires: "auto",
+        // TODO: set to true (default) in v3
+        esmExternals: (id) => !id.startsWith("unenv/"),
+        requireReturnsDefault: "auto",
+        ...ctx.nitro.options.commonJS
+      }
+    },
+    resolve: {
+      noExternal: ctx.nitro.options.dev ? (
+        // Workaround for dev: external dependencies are not resolvable with respect to nodeModulePaths
+        new RegExp(runtimeDependencies.join("|"))
+      ) : void 0,
+      conditions: ctx.nitro.options.exportConditions,
+      externalConditions: ctx.nitro.options.exportConditions
+    },
+    dev: {
+      createEnvironment: (envName, envConfig) => createFetchableDevEnvironment(
+        envName,
+        envConfig,
+        ctx.devWorker,
+        resolve$1(runtimeDir, "internal/vite/dev-entry.mjs")
+      )
+    }
+  };
+}
+function createServiceEnvironment(ctx, name, serviceConfig) {
+  return {
+    consumer: "server",
+    build: {
+      rollupOptions: { input: serviceConfig.entry },
+      minify: ctx.nitro.options.minify,
+      outDir: join$1(ctx.nitro.options.buildDir, "vite", "services", name),
+      emptyOutDir: true
+    },
+    resolve: {
+      conditions: ctx.nitro.options.exportConditions,
+      externalConditions: ctx.nitro.options.exportConditions
+    },
+    dev: {
+      createEnvironment: (envName, envConfig) => createFetchableDevEnvironment(
+        envName,
+        envConfig,
+        ctx.devWorker,
+        tryResolve(serviceConfig.entry)
+      )
+    }
+  };
+}
+function createServiceEnvironments(ctx) {
+  return Object.fromEntries(
+    Object.entries(ctx.pluginConfig.services || {}).map(([name, config]) => [
+      name,
+      createServiceEnvironment(ctx, name, config)
+    ])
+  );
+}
+function tryResolve(id) {
+  if (/^[~#/\0]/.test(id) || isAbsolute(id)) {
+    return id;
+  }
+  const resolved = resolveModulePath(id, {
+    suffixes: ["", "/index"],
+    extensions: ["", ".ts", ".mjs", ".cjs", ".js", ".mts", ".cts"],
+    try: true
+  });
+  return resolved || id;
+}
+
+function nitroPreviewPlugin(ctx) {
+  return {
+    name: "nitro:preview",
+    apply: (_config, configEnv) => !!configEnv.isPreview,
+    config(config) {
+      return {
+        preview: {
+          port: config.preview?.port || 3e3
+        }
+      };
+    },
+    async configurePreviewServer(server) {
+      const buildInfoPath = resolve(
+        server.config.root,
+        "node_modules/.nitro/last-build",
+        "nitro.json"
+      );
+      if (!existsSync(buildInfoPath)) {
+        console.warn(
+          `[nitro] No build found. Please build your project before previewing.`
+        );
+        return;
+      }
+      const realBuildDir = await readlink("node_modules/.nitro/last-build");
+      const buildInfo = JSON.parse(
+        await readFile(buildInfoPath, "utf8")
+      );
+      const info = [
+        ["Build Directory:", prettyPath(realBuildDir)],
+        ["Date:", buildInfo.date && new Date(buildInfo.date).toLocaleString()],
+        ["Nitro Version:", buildInfo.versions.nitro],
+        ["Nitro Preset:", buildInfo.preset],
+        buildInfo.framework?.name !== "nitro" && [
+          "Framework:",
+          buildInfo.framework?.name + (buildInfo.framework?.version ? ` (v${buildInfo.framework.version})` : "")
+        ]
+      ].filter((i) => i && i[1]);
+      consola.box({
+        title: " [Build Info] ",
+        message: info.map((i) => `- ${i[0]} ${i[1]}`).join("\n")
+      });
+      if (!buildInfo.commands?.preview) {
+        consola.warn("[nitro] No preview command found for this preset..");
+        return;
+      }
+      const randomPort = await getRandomPort();
+      consola.info(`Spawning preview server...`);
+      const [command, ...args] = buildInfo.commands.preview.split(" ");
+      let child;
+      consola.info(buildInfo.commands?.preview);
+      child = spawn(command, args, {
+        stdio: "inherit",
+        cwd: realBuildDir,
+        env: {
+          ...process.env,
+          PORT: String(randomPort)
+        }
+      });
+      process.on("exit", () => {
+        child?.kill();
+        child = void 0;
+      });
+      child.on("exit", (code) => {
+        if (code && code !== 0) {
+          consola.error(`[nitro] Preview server exited with code ${code}`);
+        }
+      });
+      const proxy = createProxyServer({
+        target: `http://localhost:${randomPort}`
+      });
+      server.middlewares.use((req, res, next) => {
+        if (child && !child.killed) {
+          proxy.web(req, res).catch(next);
+        } else {
+          res.end(`Nitro preview server is not running.`);
+        }
+      });
+    }
+  };
+}
+
+const DEFAULT_EXTENSIONS = [".ts", ".js", ".mts", ".mjs", ".tsx", ".jsx"];
+const debug = process.env.NITRO_DEBUG ? (...args) => console.log("[nitro]", ...args) : () => {
+};
+function nitro(pluginConfig = {}) {
+  const ctx = createContext(pluginConfig);
+  return [
+    nitroInit(ctx),
+    nitroEnv(ctx),
+    nitroMain(ctx),
+    nitroPrepare(ctx),
+    nitroService(ctx),
+    nitroPreviewPlugin(),
+    pluginConfig.experimental?.assetsImport !== false && assetsPlugin({
+      experimental: {
+        // See https://github.com/hi-ogawa/vite-plugins/pull/1289
+        clientBuildFallback: false
+      }
+    })
+  ];
+}
+function nitroInit(ctx) {
+  return {
+    name: "nitro:init",
+    sharedDuringBuild: true,
+    apply: (_config, configEnv) => !configEnv.isPreview,
+    async config(config, configEnv) {
+      if (!ctx._initialized) {
+        debug("[init] Initializing nitro");
+        ctx._initialized = true;
+        await setupNitroContext(ctx, configEnv, config);
+      }
+    },
+    applyToEnvironment(env) {
+      if (env.name === "nitro" && ctx.nitro?.options.dev) {
+        debug("[init] Adding rollup plugins for dev");
+        return [...ctx.rollupConfig?.config.plugins || []];
+      }
+    }
+  };
+}
+function nitroEnv(ctx) {
+  return {
+    name: "nitro:env",
+    sharedDuringBuild: true,
+    apply: (_config, configEnv) => !configEnv.isPreview,
+    async config(userConfig, _configEnv) {
+      debug("[env]  Extending config (environments)");
+      const environments = {
+        ...createServiceEnvironments(ctx),
+        nitro: createNitroEnvironment(ctx)
+      };
+      environments.client = {
+        consumer: userConfig.environments?.client?.consumer ?? "client",
+        build: {
+          rollupOptions: {
+            input: userConfig.environments?.client?.build?.rollupOptions?.input ?? useNitro(ctx).options.renderer?.template
+          }
+        }
+      };
+      debug("[env]  Environments:", Object.keys(environments).join(", "));
+      return {
+        environments
+      };
+    },
+    configEnvironment(name, config) {
+      if (config.consumer === "client") {
+        debug(
+          "[env]  Configuring client environment",
+          name === "client" ? "" : ` (${name})`
+        );
+        config.build.emptyOutDir = false;
+        config.build.outDir = useNitro(ctx).options.output.publicDir;
+      } else {
+        if (ctx.pluginConfig.experimental?.virtualBundle && name in (ctx.pluginConfig.services || {})) {
+          debug("[env]  Configuring service environment for virtual:", name);
+          config.build ??= {};
+          config.build.write = config.build.write ?? false;
+        }
+      }
+    }
+  };
+}
+function nitroMain(ctx) {
+  return {
+    name: "nitro:main",
+    sharedDuringBuild: true,
+    apply: (_config, configEnv) => !configEnv.isPreview,
+    async config(userConfig, _configEnv) {
+      debug("[main] Extending config (appType, resolve, server)");
+      if (!ctx.rollupConfig) {
+        throw new Error("Nitro rollup config is not initialized yet.");
+      }
+      return {
+        appType: userConfig.appType || "custom",
+        resolve: {
+          // TODO: environment specific aliases not working
+          // https://github.com/vitejs/vite/pull/17583 (seems not effective)
+          alias: ctx.rollupConfig.base.aliases
+        },
+        builder: {
+          sharedConfigBuild: true
+        },
+        server: {
+          port: Number.parseInt(process.env.PORT || "") || userConfig.server?.port || useNitro(ctx).options.devServer?.port || 3e3
+        }
+      };
+    },
+    configResolved(config) {
+      if (config.command === "build") {
+        debug("[main] Inferring caching routes");
+        for (const env of Object.values(config.environments)) {
+          if (env.consumer === "client") {
+            const rule = ctx.nitro.options.routeRules[`/${env.build.assetsDir}/**`] ??= {};
+            if (!rule.headers?.["cache-control"]) {
+              rule.headers = {
+                ...rule.headers,
+                "cache-control": `public, max-age=31536000, immutable`
+              };
+            }
+          }
+        }
+      }
+      debug("[main] Syncing nitro routes");
+      ctx.nitro.routing.sync();
+    },
+    buildApp: {
+      order: "post",
+      handler(builder) {
+        debug("[main] Building environments");
+        return buildEnvironments(ctx, builder);
+      }
+    },
+    generateBundle: {
+      handler(_options, bundle) {
+        const environment = this.environment;
+        debug(
+          "[main] Generating manifest and entry points for environment:",
+          environment.name
+        );
+        const { root } = environment.config;
+        const services = ctx.pluginConfig.services || {};
+        const serviceNames = Object.keys(services);
+        const isRegisteredService = serviceNames.includes(environment.name);
+        let entryFile;
+        for (const [_name, file] of Object.entries(bundle)) {
+          if (file.type === "chunk") {
+            if (isRegisteredService && file.isEntry) {
+              if (entryFile === void 0) {
+                entryFile = file.fileName;
+              } else {
+                this.warn(
+                  `Multiple entry points found for service "${environment.name}"`
+                );
+              }
+            }
+            const filteredModuleIds = file.moduleIds.filter(
+              (id) => id.startsWith(root)
+            );
+            for (const id of filteredModuleIds) {
+              const originalFile = relative(root, id);
+              ctx._manifest[originalFile] = { file: file.fileName };
+            }
+          }
+        }
+        if (isRegisteredService) {
+          if (entryFile === void 0) {
+            this.error(
+              `No entry point found for service "${this.environment.name}".`
+            );
+          }
+          ctx._entryPoints[this.environment.name] = entryFile;
+          ctx._serviceBundles[this.environment.name] = bundle;
+        }
+      }
+    },
+    configureServer: (server) => {
+      debug("[main] Configuring dev server");
+      return configureViteDevServer(ctx, server);
+    }
+  };
+}
+function nitroPrepare(ctx) {
+  return {
+    name: "nitro:prepare",
+    sharedDuringBuild: true,
+    applyToEnvironment: (env) => env.name === "nitro",
+    buildApp: {
+      // Clean the output directory before any environment is built
+      order: "pre",
+      async handler() {
+        debug("[prepare] Preparing output directory");
+        const nitro2 = ctx.nitro;
+        await prepare(nitro2);
+      }
+    }
+  };
+}
+function nitroService(ctx) {
+  return {
+    name: "nitro:service",
+    enforce: "pre",
+    sharedDuringBuild: true,
+    applyToEnvironment: (env) => env.name === "nitro",
+    resolveId: {
+      async handler(id, importer, options) {
+        if (id === "#nitro-vite-setup") {
+          return { id, moduleSideEffects: true };
+        }
+        if (id === "#nitro-vite-services") {
+          return id;
+        }
+        if (runtimeDependencies.some(
+          (dep) => id === dep || id.startsWith(`${dep}/`)
+        )) {
+          const resolved = await this.resolve(id, importer, {
+            ...options,
+            skipSelf: true
+          });
+          return resolved || resolveModulePath(id, {
+            from: ctx.nitro.options.nodeModulesDirs,
+            conditions: ctx.nitro.options.exportConditions,
+            try: true
+          });
+        }
+        if (importer?.startsWith("\0virtual:#nitro-internal-virtual")) {
+          const internalRes = await this.resolve(id, import.meta.url, {
+            ...options,
+            custom: { ...options.custom, skipNoExternals: true }
+          });
+          if (internalRes) {
+            return internalRes;
+          }
+          const resolvedFromRoot = await this.resolve(
+            id,
+            ctx.nitro.options.rootDir,
+            { ...options, custom: { ...options.custom, skipNoExternals: true } }
+          );
+          if (resolvedFromRoot) {
+            return resolvedFromRoot;
+          }
+          const ids = [id];
+          if (!/^[./@#]/.test(id)) {
+            ids.push(`./${id}`);
+          }
+          for (const _id of ids) {
+            const resolved = resolveModulePath(_id, {
+              from: process.cwd(),
+              extensions: DEFAULT_EXTENSIONS,
+              suffixes: ["", "/index"],
+              try: true
+            });
+            if (resolved) {
+              return resolved;
+            }
+          }
+        }
+      }
+    },
+    load: {
+      async handler(id) {
+        if (id === "#nitro-vite-setup") {
+          return prodSetup(ctx);
+        }
+      }
+    }
+  };
+}
+function createContext(pluginConfig) {
+  return {
+    pluginConfig,
+    _entryPoints: {},
+    _manifest: {},
+    _serviceBundles: {}
+  };
+}
+function useNitro(ctx) {
+  if (!ctx.nitro) {
+    throw new Error("Nitro instance is not initialized yet.");
+  }
+  return ctx.nitro;
+}
+async function setupNitroContext(ctx, configEnv, userConfig) {
+  ctx.nitro = ctx.pluginConfig._nitro || await createNitro({
+    dev: configEnv.mode === "development",
+    rootDir: userConfig.root,
+    ...defu(ctx.pluginConfig.config, userConfig.nitro)
+  });
+  if (!ctx.pluginConfig.services?.ssr) {
+    ctx.pluginConfig.services ??= {};
+    if (userConfig.environments?.ssr === void 0) {
+      const ssrEntry = resolveModulePath("./entry-server", {
+        from: ["", "app", "src"].flatMap(
+          (d) => ctx.nitro.options.scanDirs.map((s) => join(s, d) + "/")
+        ),
+        extensions: DEFAULT_EXTENSIONS,
+        try: true
+      });
+      if (ssrEntry) {
+        ctx.pluginConfig.services.ssr = { entry: ssrEntry };
+        ctx.nitro.logger.info(
+          `Using \`${prettyPath(ssrEntry)}\` as vite ssr entry.`
+        );
+      }
+    } else {
+      let ssrEntry = getEntry(
+        userConfig.environments.ssr.build?.rollupOptions?.input
+      );
+      if (typeof ssrEntry === "string") {
+        ssrEntry = resolveModulePath(ssrEntry, {
+          from: ctx.nitro.options.scanDirs,
+          extensions: DEFAULT_EXTENSIONS,
+          suffixes: ["", "/index"],
+          try: true
+        }) || ssrEntry;
+        ctx.pluginConfig.services.ssr = { entry: ssrEntry };
+      } else {
+        throw new TypeError(`Invalid input type for SSR entry point.`);
+      }
+    }
+  }
+  if (!ctx.nitro.options.renderer?.entry && !ctx.nitro.options.renderer?.template && ctx.pluginConfig.services.ssr?.entry) {
+    ctx.nitro.options.renderer ??= {};
+    ctx.nitro.options.renderer.entry = resolve(
+      runtimeDir,
+      "internal/vite/ssr-renderer"
+    );
+  }
+  const publicDistDir = ctx._publicDistDir = userConfig.build?.outDir || resolve(ctx.nitro.options.buildDir, "vite/public");
+  ctx.nitro.options.publicAssets.push({
+    dir: publicDistDir,
+    maxAge: 0,
+    baseURL: "/",
+    fallthrough: true
+  });
+  if (!ctx.nitro.options.dev) {
+    ctx.nitro.options.unenv.push({
+      meta: { name: "nitro-vite" },
+      polyfill: ["#nitro-vite-setup"]
+    });
+  }
+  await ctx.nitro.hooks.callHook("build:before", ctx.nitro);
+  ctx.rollupConfig = await getViteRollupConfig(ctx);
+  await ctx.nitro.hooks.callHook(
+    "rollup:before",
+    ctx.nitro,
+    ctx.rollupConfig.config
+  );
+  if (ctx.nitro.options.dev && !ctx.devWorker) {
+    ctx.devWorker = createDevWorker(ctx);
+  }
+  if (ctx.nitro.options.dev && !ctx.devApp) {
+    ctx.devApp = new NitroDevApp(ctx.nitro);
+  }
+}
+function getEntry(input) {
+  if (typeof input === "string") {
+    return input;
+  } else if (Array.isArray(input) && input.length > 0) {
+    return input[0];
+  } else if (input && "index" in input) {
+    return input.index;
+  }
+}
+
+async function viteBuild(nitro$1) {
+  if (nitro$1.options.dev) {
+    throw new Error(
+      "Nitro vite builder is not supported in development mode. Please use `vite dev` instead."
+    );
+  }
+  const { createBuilder } = await import('vite');
+  const builder = await createBuilder({
+    base: nitro$1.options.rootDir,
+    plugins: [await nitro({ _nitro: nitro$1 })],
+    logLevel: isTest ? "warn" : void 0
+  });
+  await builder.buildApp();
+}
+
+const build = {
+  __proto__: null,
+  viteBuild: viteBuild
+};
+
+export { NitroDevServer as N, createDevServer as a, listTasks as b, createNitro as c, build as d, loadOptions as l, nitro as n, prerender as p, runTask as r };