nitro-nightly 3.1.0-20251028-090722-437659e4 → 3.1.0-20251028-131831-fe9fd554

package/dist/_build/vite.mjs

@@ -1,2290 +1,46 @@
-import { pathToFileURL } from 'node:url';
+import { g as copyPublicAssets, s as scanHandlers, h as prettyPath, p as prepare, c as createNitro } from './prepare.mjs';
+import '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 { defu } from 'defu';
+import '../_chunks/_deps/mime.mjs';
+import 'ufo';
 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 { readFile, rm, mkdir, writeFile, readlink } from 'node:fs/promises';
 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 'node:worker_threads';
+import consola from 'consola';
+import 'h3';
+import 'undici';
+import 'nitro/meta';
+import { NodeRequest, sendNodeResponse } from 'srvx/node';
+import { a as NodeDevWorker, N as NitroDevApp } from '../_chunks/app.mjs';
+import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
+import { r as resolveModulePath } from '../_chunks/_deps/exsolve.mjs';
+import 'ofetch';
+import { s as sanitizeFilePath } from '../_chunks/_deps/mlly.mjs';
+import { a as alias } from '../_chunks/_deps/@rollup/plugin-alias.mjs';
+import { i as inject } from '../_chunks/_deps/@rollup/plugin-inject.mjs';
+import { b as baseBuildConfig, a as baseBuildPlugins, r as replace, w as writeBuildInfo } from './info.mjs';
+import { r as resolve, d as dirname, n as normalize, b as basename, a as relative, j as join, i as isAbsolute } from '../_chunks/_deps/pathe.mjs';
+import { f as formatCompatibilityDate } from '../_chunks/_deps/compatx.mjs';
+import 'hookable';
+import 'jiti';
 import 'unstorage';
-import { w as writeBuildInfo } from './info.mjs';
+import 'ohash';
+import { a, T } from '../_chunks/_deps/std-env.mjs';
+import '../_chunks/_deps/serve-static.mjs';
+import { resolve as resolve$1, join as join$1 } from 'node:path';
+import 'youch-core';
+import 'youch';
+import 'source-map';
+import 'srvx';
 import { DevEnvironment } from 'vite';
+import { watch } from '../_chunks/_deps/chokidar.mjs';
+import { d as debounce } from '../_chunks/_deps/perfect-debounce.mjs';
 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
-}
+import { c as createProxyServer } from '../_chunks/_deps/httpxy.mjs';
+import { a as assetsPlugin } from '../_chunks/_deps/@pi0/vite-plugin-fullstack.mjs';
 
 const getViteRollupConfig = (ctx) => {
   const nitro = ctx.nitro;
@@ -2413,7 +169,7 @@ function virtualBundlePlugin(bundles) {
         return resolve(id);
       }
       if (importer) {
-        const resolved = resolve(dirname$1(importer), id);
+        const resolved = resolve(dirname(importer), id);
         if (modules.has(resolved)) {
           return resolved;
         }
@@ -2448,7 +204,7 @@ async function buildEnvironments(ctx, builder) {
       }
       continue;
     }
-    if (!isTest && !isCI) console.log();
+    if (!a && !T) console.log();
     nitro.logger.start(`Building [${fmtName}]`);
     await builder.build(env);
   }
@@ -2468,13 +224,13 @@ async function buildEnvironments(ctx, builder) {
       );
       await rm(outputPath);
       const tmp = resolve(nitroOptions.buildDir, "vite/index.html");
-      await mkdir(dirname$1(tmp), { recursive: true });
-      await writeFile$1(tmp, html, "utf8");
+      await mkdir(dirname(tmp), { recursive: true });
+      await writeFile(tmp, html, "utf8");
       nitroOptions.renderer.template = tmp;
     }
   }
   await builder.writeAssetsManifest?.();
-  if (!isTest && !isCI) console.log();
+  if (!a && !T) console.log();
   const buildInfo = [
     ["preset", nitro.options.preset],
     ["compatibility", formatCompatibilityDate(nitro.options.compatibilityDate)]
@@ -2491,7 +247,7 @@ async function buildEnvironments(ctx, builder) {
   const rewriteRelativePaths = (input) => {
     return input.replace(/([\s:])\.\/(\S*)/g, `$1${rOutput}/$2`);
   };
-  if (!isTest && !isCI) console.log();
+  if (!a && !T) console.log();
   if (nitro.options.commands.preview) {
     nitro.logger.success(
       `You can preview this build using \`${rewriteRelativePaths(
@@ -3243,24 +999,4 @@ function getEntry(input) {
   }
 }
 
-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 };
+export { nitro as n };