nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-122334-09c1a7a8

package/dist/_build/vite.mjs

@@ -1,959 +0,0 @@
-import { e as copyPublicAssets, s as scanHandlers, h as prettyPath, p as prepare, c as createNitro } from './prepare.mjs';
-import consola from 'consola';
-import { existsSync, watch as watch$1 } from 'node:fs';
-import { defu } from 'defu';
-import 'ufo';
-import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
-import { r as resolveModulePath } from '../_chunks/_deps/exsolve.mjs';
-import { readFile, rm, mkdir, writeFile, readlink } from 'node:fs/promises';
-import 'node:zlib';
-import '../_chunks/_deps/mime.mjs';
-import 'node:worker_threads';
-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 'node:url';
-import { colors } from 'consola/utils';
-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 '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 { 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;
-  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(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 (!a && !T) 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(tmp), { recursive: true });
-      await writeFile(tmp, html, "utf8");
-      nitroOptions.renderer.template = tmp;
-    }
-  }
-  await builder.writeAssetsManifest?.();
-  if (!a && !T) 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 (!a && !T) 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("|"))
-      ) : true,
-      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,
-          // #3673, disable Vite's `cors` by default as Nitro handles all requests
-          cors: false
-        }
-      };
-    },
-    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) {
-        if (id === "#nitro-vite-setup") {
-          return { id, moduleSideEffects: true };
-        }
-        if (id === "#nitro-vite-services") {
-          return id;
-        }
-      }
-    },
-    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;
-  }
-}
-
-export { nitro as n };