nitro-nightly 3.0.0-beta-28969273.f7aa9de6 → 4.0.0-20251010-091516-7cafddba

package/dist/_chunks/plugin.mjs

@@ -0,0 +1,960 @@
+import { s as sanitizeFilePath, f as formatCompatibilityDate, d as copyPublicAssets, a as scanHandlers, r as resolveModulePath, e as prettyPath, i as createNitro, j as prepare } from './index.mjs';
+import { fileURLToPath } from 'node:url';
+import { colors } from 'consola/utils';
+import { defu } from 'defu';
+import 'ufo';
+import { existsSync, watch as watch$1 } from 'node:fs';
+import { readFile, rm, mkdir, writeFile, readlink } from 'node:fs/promises';
+import 'node:zlib';
+import 'node:worker_threads';
+import consola from 'consola';
+import 'std-env';
+import 'h3';
+import 'undici';
+import 'nitro/meta';
+import { NodeRequest, sendNodeResponse } from 'srvx/node';
+import { d as debounce, w as watch, a as NodeDevWorker, c as createProxyServer, N as NitroDevApp } from './app.mjs';
+import 'klona/full';
+import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
+import 'ofetch';
+import { a as alias, i as inject } from './index2.mjs';
+import { b as baseBuildConfig, d as baseBuildPlugins, r as replace, e 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 './pathe.M-eThtNZ.mjs';
+import 'hookable';
+import 'jiti';
+import 'klona';
+import 'unstorage';
+import 'ohash';
+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 { getRandomPort } from 'get-port-please';
+import { spawn } from 'node:child_process';
+
+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"],
+    ["\0raw:", "raw"],
+    ["\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({ 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;
+    }
+    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;
+    }
+  }
+  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 nitro.hooks.callHook(
+    "rollup:before",
+    nitro,
+    builder.environments.nitro.config.build.rollupOptions
+  );
+  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`);
+  };
+  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");
+    }
+    if (!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("|"))
+      ) : (
+        // Workaround for build: externals tracing is unstable
+        ctx.nitro.options.noExternals === false ? void 0 : true
+      ),
+      // prettier-ignore
+      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: {
+      noExternal: ctx.nitro.options.dev ? void 0 : true,
+      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"];
+function nitro(pluginConfig = {}) {
+  const ctx = {
+    pluginConfig,
+    _entryPoints: {},
+    _manifest: {},
+    _serviceBundles: {}
+  };
+  return [
+    nitroPlugin(ctx),
+    nitroServicePlugin(ctx),
+    nitroPreviewPlugin(),
+    nitroRollupPlugins(ctx)
+  ];
+}
+function nitroPlugin(ctx) {
+  return [
+    {
+      name: "nitro:main",
+      // Opt-in this plugin into the shared plugins pipeline
+      sharedDuringBuild: true,
+      // Only apply this plugin during build or dev
+      apply: (config, configEnv) => !configEnv.isPreview,
+      // Extend vite config before it's resolved
+      async config(userConfig, configEnv) {
+        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 {
+              this.error(`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);
+        if (ctx.nitro.options.dev && !ctx.devWorker) {
+          ctx.devWorker = createDevWorker(ctx);
+        }
+        if (ctx.nitro.options.dev && !ctx.devApp) {
+          ctx.devApp = new NitroDevApp(ctx.nitro);
+        }
+        return {
+          // Don't include HTML middlewares
+          appType: userConfig.appType || "custom",
+          // Add Nitro as a Vite environment
+          environments: {
+            client: {
+              consumer: userConfig.environments?.client?.consumer ?? "client",
+              build: {
+                rollupOptions: {
+                  input: userConfig.environments?.client?.build?.rollupOptions?.input ?? ctx.nitro.options.renderer?.template
+                }
+              }
+            },
+            ...createServiceEnvironments(ctx),
+            nitro: createNitroEnvironment(ctx)
+          },
+          resolve: {
+            // TODO: environment specific aliases not working
+            // https://github.com/vitejs/vite/pull/17583 (seems not effective)
+            alias: ctx.rollupConfig.base.aliases
+          },
+          build: {
+            // TODO: Support server environment emitted assets
+            assetsInlineLimit: 4096 * 4
+          },
+          builder: {
+            /// Share the config instance among environments to align with the behavior of dev server
+            sharedConfigBuild: true
+          },
+          server: {
+            port: Number.parseInt(process.env.PORT || "") || userConfig.server?.port || ctx.nitro.options.devServer?.port || 3e3
+          }
+        };
+      },
+      configResolved(config) {
+        if (config.command === "build") {
+          for (const env of Object.values(config.environments)) {
+            if (env.consumer === "client") {
+              const { assetsDir } = env.build;
+              const rule = ctx.nitro.options.routeRules[`/${assetsDir}/**`] ??= {};
+              if (!rule.headers?.["cache-control"]) {
+                rule.headers = {
+                  ...rule.headers,
+                  "cache-control": `public, max-age=31536000, immutable`
+                };
+              }
+            }
+          }
+        }
+        ctx.nitro.routing.sync();
+      },
+      buildApp: {
+        order: "post",
+        handler(builder) {
+          return buildEnvironments(ctx, builder);
+        }
+      },
+      generateBundle: {
+        handler(_options, bundle) {
+          const { root } = this.environment.config;
+          const services = ctx.pluginConfig.services || {};
+          const serviceNames = Object.keys(services);
+          const isRegisteredService = serviceNames.includes(
+            this.environment.name
+          );
+          let entryFile;
+          for (const [_name, file] of Object.entries(bundle)) {
+            if (file.type === "chunk") {
+              if (isRegisteredService && file.isEntry) {
+                if (entryFile !== void 0) {
+                  this.error(
+                    `Multiple entry points found for service "${this.environment.name}". Only one entry point is allowed.`
+                  );
+                }
+                entryFile = file.fileName;
+              }
+              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;
+          }
+        }
+      },
+      // Modify environment configs before it's resolved.
+      configEnvironment(name, config) {
+        if (config.consumer === "client") {
+          config.build.emptyOutDir = false;
+          config.build.outDir = ctx.nitro.options.output.publicDir;
+        }
+        const services = ctx.pluginConfig.services || {};
+        const serviceNames = Object.keys(services);
+        if (serviceNames.includes(name) && ctx.pluginConfig.experimental?.virtualBundle) {
+          config.build ??= {};
+          config.build.write = config.build.write ?? false;
+        }
+      },
+      // Extend Vite dev server with Nitro middleware
+      configureServer: (server) => configureViteDevServer(ctx, server)
+    },
+    {
+      name: "nitro:prepare",
+      buildApp: {
+        // clean the output directory before any environment is built
+        order: "pre",
+        async handler() {
+          const nitro2 = ctx.nitro;
+          await prepare(nitro2);
+        }
+      }
+    }
+  ];
+}
+function nitroServicePlugin(ctx) {
+  return {
+    name: "nitro:service",
+    enforce: "pre",
+    // Only apply this plugin to the nitro environment
+    applyToEnvironment: (env) => env.name === "nitro",
+    resolveId: {
+      async handler(id, importer, options) {
+        if (id === "#nitro-vite-setup") {
+          return { id, moduleSideEffects: true };
+        }
+        if (id === "#nitro-vite-services") {
+          return id;
+        }
+        if (runtimeDependencies.some(
+          (dep) => id === dep || id.startsWith(`${dep}/`)
+        )) {
+          const resolved = await this.resolve(id, importer, {
+            ...options,
+            skipSelf: true
+          });
+          return resolved || resolveModulePath(id, {
+            from: ctx.nitro.options.nodeModulesDirs,
+            conditions: ctx.nitro.options.exportConditions,
+            try: true
+          });
+        }
+        if (importer?.startsWith("\0virtual:#nitro-internal-virtual")) {
+          const internalRes = await this.resolve(id, import.meta.url, {
+            ...options,
+            custom: { ...options.custom, skipNoExternals: true }
+          });
+          if (internalRes) {
+            return internalRes;
+          }
+          const resolvedFromRoot = await this.resolve(
+            id,
+            ctx.nitro.options.rootDir,
+            { ...options, custom: { ...options.custom, skipNoExternals: true } }
+          );
+          if (resolvedFromRoot) {
+            return resolvedFromRoot;
+          }
+          const ids = [id];
+          if (!/^[./@#]/.test(id)) {
+            ids.push(`./${id}`);
+          }
+          for (const _id of ids) {
+            const resolved = resolveModulePath(_id, {
+              from: process.cwd(),
+              extensions: DEFAULT_EXTENSIONS,
+              suffixes: ["", "/index"],
+              try: true
+            });
+            if (resolved) {
+              return resolved;
+            }
+          }
+        }
+      }
+    },
+    load: {
+      async handler(id) {
+        if (id === "#nitro-vite-setup") {
+          return prodSetup(ctx);
+        }
+      }
+    }
+  };
+}
+function nitroRollupPlugins(ctx) {
+  const createHookCaller = (hook, order) => {
+    const handler = async function(...args) {
+      for (const plugin of ctx.rollupConfig.config.plugins) {
+        if (typeof plugin[hook] !== "function") continue;
+        const res = await plugin[hook].call(this, ...args);
+        if (res) {
+          if (hook === "resolveId" && res.id?.startsWith?.("file://")) {
+            res.id = fileURLToPath(res.id);
+          }
+          return res;
+        }
+      }
+    };
+    Object.defineProperty(handler, "name", { value: hook });
+    return order ? { order, handler } : handler;
+  };
+  return {
+    name: "nitro:rollup-hooks",
+    applyToEnvironment: (env) => env.name === "nitro",
+    buildStart: createHookCaller("buildStart", "pre"),
+    resolveId: createHookCaller("resolveId", "pre"),
+    load: createHookCaller("load", "pre"),
+    transform: createHookCaller("transform", "post"),
+    renderChunk: createHookCaller("renderChunk", "post"),
+    generateBundle: createHookCaller("generateBundle", "post"),
+    buildEnd: createHookCaller("buildEnd", "post")
+  };
+}
+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 };