nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/{_chunks/plugin.mjs → _build/vite.mjs}

@@ -1,38 +1,46 @@
-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 { 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 { existsSync, watch as watch$1 } from 'node:fs';
+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 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 { a as NodeDevWorker, N as NitroDevApp } from '../_chunks/app.mjs';
+import 'node:url';
+import { colors } from 'consola/utils';
 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 { 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 'klona';
 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;
@@ -42,7 +50,6 @@ const getViteRollupConfig = (ctx) => {
     [base.buildServerDir, "app"],
     [runtimeDir, "nitro"],
     [base.presetsDir, "nitro"],
-    ["\0raw:", "raw"],
     ["\0nitro-wasm:", "wasm"],
     ["\0", "virtual"]
   ];
@@ -58,7 +65,11 @@ const getViteRollupConfig = (ctx) => {
       ctx.pluginConfig.experimental?.virtualBundle && virtualBundlePlugin(ctx._serviceBundles),
       ...baseBuildPlugins(nitro, base),
       alias({ entries: base.aliases }),
-      replace({ preventAssignment: true, values: base.replacements }),
+      replace({
+        delimiters: base.replaceDelimiters,
+        preventAssignment: true,
+        values: base.replacements
+      }),
       inject(base.env.inject)
     ].filter(Boolean),
     treeshake: {
@@ -193,7 +204,7 @@ async function buildEnvironments(ctx, builder) {
       }
       continue;
     }
-    console.log();
+    if (!a && !T) console.log();
     nitro.logger.start(`Building [${fmtName}]`);
     await builder.build(env);
   }
@@ -218,7 +229,8 @@ async function buildEnvironments(ctx, builder) {
       nitroOptions.renderer.template = tmp;
     }
   }
-  console.log();
+  await builder.writeAssetsManifest?.();
+  if (!a && !T) console.log();
   const buildInfo = [
     ["preset", nitro.options.preset],
     ["compatibility", formatCompatibilityDate(nitro.options.compatibilityDate)]
@@ -227,11 +239,6 @@ async function buildEnvironments(ctx, builder) {
     `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);
@@ -240,7 +247,7 @@ async function buildEnvironments(ctx, builder) {
   const rewriteRelativePaths = (input) => {
     return input.replace(/([\s:])\.\/(\S*)/g, `$1${rOutput}/$2`);
   };
-  console.log();
+  if (!a && !T) console.log();
   if (nitro.options.commands.preview) {
     nitro.logger.success(
       `You can preview this build using \`${rewriteRelativePaths(
@@ -446,7 +453,8 @@ async function configureViteDevServer(ctx, server) {
     if (fetchDest) {
       res.setHeader("vary", "sec-fetch-dest");
     }
-    if (!fetchDest || /^(document|iframe|frame|empty)$/.test(fetchDest)) {
+    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();
@@ -489,11 +497,7 @@ function createNitroEnvironment(ctx) {
       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
+      ) : true,
       conditions: ctx.nitro.options.exportConditions,
       externalConditions: ctx.nitro.options.exportConditions
     },
@@ -517,7 +521,6 @@ function createServiceEnvironment(ctx, name, serviceConfig) {
       emptyOutDir: true
     },
     resolve: {
-      noExternal: ctx.nitro.options.dev ? void 0 : true,
       conditions: ctx.nitro.options.exportConditions,
       externalConditions: ctx.nitro.options.exportConditions
     },
@@ -633,280 +636,218 @@ function nitroPreviewPlugin(ctx) {
 }
 
 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 = {
-    pluginConfig,
-    _entryPoints: {},
-    _manifest: {},
-    _serviceBundles: {}
-  };
+  const ctx = createContext(pluginConfig);
   return [
-    nitroPlugin(ctx),
-    nitroServicePlugin(ctx),
+    nitroInit(ctx),
+    nitroEnv(ctx),
+    nitroMain(ctx),
+    nitroPrepare(ctx),
+    nitroService(ctx),
     nitroPreviewPlugin(),
-    nitroRollupPlugins(ctx)
+    pluginConfig.experimental?.assetsImport !== false && assetsPlugin({
+      experimental: {
+        // See https://github.com/hi-ogawa/vite-plugins/pull/1289
+        clientBuildFallback: false
+      }
+    })
   ];
 }
-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.`);
-            }
+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
           }
         }
-        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);
+      };
+      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;
         }
-        if (ctx.nitro.options.dev && !ctx.devApp) {
-          ctx.devApp = new NitroDevApp(ctx.nitro);
+      }
+    }
+  };
+}
+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
         }
-        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`
-                };
-              }
+      };
+    },
+    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`
+              };
             }
           }
         }
-        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.`
-                  );
-                }
+      }
+      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;
-              }
-              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 };
+              } else {
+                this.warn(
+                  `Multiple entry points found for service "${environment.name}"`
+                );
               }
             }
-          }
-          if (isRegisteredService) {
-            if (entryFile === void 0) {
-              this.error(
-                `No entry point found for service "${this.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 };
             }
-            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;
+        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;
         }
-      },
-      // 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);
-        }
+    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 nitroServicePlugin(ctx) {
+function nitroService(ctx) {
   return {
     name: "nitro:service",
     enforce: "pre",
-    // Only apply this plugin to the nitro environment
+    sharedDuringBuild: true,
     applyToEnvironment: (env) => env.name === "nitro",
     resolveId: {
-      async handler(id, importer, options) {
+      async handler(id) {
         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: {
@@ -918,35 +859,93 @@ function nitroServicePlugin(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;
-  };
+function createContext(pluginConfig) {
   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")
+    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;