nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-121649-98b56dfe

package/dist/_chunks/plugin.mjs

@@ -1,960 +0,0 @@
-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 };