nitro-nightly 3.1.0-20251028-004953-57503e42 → 3.1.0-20251028-110430-e607b753

package/dist/_chunks/plugin.mjs

@@ -1,1560 +0,0 @@
-import { s as sanitizeFilePath, f as formatCompatibilityDate, d as copyPublicAssets, a as scanHandlers, r as resolveModulePath, e as prettyPath, M as MagicString, i as stripLiteral, j as prepare, k as createNitro } from './index.mjs';
-import { fileURLToPath } from 'node:url';
-import { colors } from 'consola/utils';
-import { defu } from 'defu';
-import 'ufo';
-import fs, { 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 { isTest, isCI } from '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 path, { resolve as resolve$1, join as join$1 } from 'node:path';
-import 'youch-core';
-import 'youch';
-import 'source-map';
-import 'srvx';
-import { DevEnvironment, normalizePath, isCSSRequest } from 'vite';
-import { getRandomPort } from 'get-port-please';
-import { spawn } from 'node:child_process';
-import assert from 'node:assert/strict';
-import 'node:assert';
-import { createHash } from 'node:crypto';
-
-const getViteRollupConfig = (ctx) => {
-  const nitro = ctx.nitro;
-  const base = baseBuildConfig(nitro);
-  const chunkNamePrefixes = [
-    [nitro.options.buildDir, "build"],
-    [base.buildServerDir, "app"],
-    [runtimeDir, "nitro"],
-    [base.presetsDir, "nitro"],
-    ["\0nitro-wasm:", "wasm"],
-    ["\0", "virtual"]
-  ];
-  function getChunkGroup(id) {
-    if (id.startsWith(runtimeDir) || id.startsWith(base.presetsDir)) {
-      return "nitro";
-    }
-  }
-  let config = {
-    input: nitro.options.entry,
-    external: [...base.env.external],
-    plugins: [
-      ctx.pluginConfig.experimental?.virtualBundle && virtualBundlePlugin(ctx._serviceBundles),
-      ...baseBuildPlugins(nitro, base),
-      alias({ entries: base.aliases }),
-      replace({
-        delimiters: base.replaceDelimiters,
-        preventAssignment: true,
-        values: base.replacements
-      }),
-      inject(base.env.inject)
-    ].filter(Boolean),
-    treeshake: {
-      moduleSideEffects(id) {
-        const normalizedId = normalize(id);
-        const idWithoutNodeModules = normalizedId.split("node_modules/").pop();
-        if (!idWithoutNodeModules) {
-          return false;
-        }
-        if (normalizedId.startsWith(runtimeDir) || idWithoutNodeModules.startsWith(runtimeDir)) {
-          return true;
-        }
-        return nitro.options.moduleSideEffects.some(
-          (m) => normalizedId.startsWith(m) || idWithoutNodeModules.startsWith(m)
-        );
-      }
-    },
-    output: {
-      dir: nitro.options.output.serverDir,
-      entryFileNames: "index.mjs",
-      chunkFileNames(chunk) {
-        const id = normalize(chunk.moduleIds.at(-1) || "");
-        for (const [dir, name] of chunkNamePrefixes) {
-          if (id.startsWith(dir)) {
-            return `chunks/${name}/[name].mjs`;
-          }
-        }
-        const routeHandler = nitro.options.handlers.find(
-          (h) => id.startsWith(h.handler)
-        ) || nitro.scannedHandlers.find((h) => id.startsWith(h.handler));
-        if (routeHandler?.route) {
-          const path = routeHandler.route.replace(/:([^/]+)/g, "_$1").replace(/\/[^/]+$/g, "") || "/";
-          return `chunks/routes/${path}/[name].mjs`.replace(/\/+/g, "/");
-        }
-        const taskHandler = Object.entries(nitro.options.tasks).find(
-          ([_, task]) => task.handler === id
-        );
-        if (taskHandler) {
-          return `chunks/tasks/[name].mjs`;
-        }
-        return `chunks/_/[name].mjs`;
-      },
-      manualChunks(id) {
-        return getChunkGroup(id);
-      },
-      inlineDynamicImports: nitro.options.inlineDynamicImports,
-      format: "esm",
-      exports: "auto",
-      intro: "",
-      outro: "",
-      generatedCode: {
-        constBindings: true
-      },
-      sanitizeFileName: sanitizeFilePath,
-      sourcemapExcludeSources: true,
-      sourcemapIgnoreList(relativePath) {
-        return relativePath.includes("node_modules");
-      }
-    }
-  };
-  config = defu(nitro.options.rollupConfig, config);
-  if (config.output.inlineDynamicImports) {
-    delete config.output.manualChunks;
-  }
-  return { config, base };
-};
-function virtualBundlePlugin(bundles) {
-  let _modules = null;
-  const getModules = () => {
-    if (_modules) {
-      return _modules;
-    }
-    _modules = /* @__PURE__ */ new Map();
-    for (const bundle of Object.values(bundles)) {
-      for (const [fileName, content] of Object.entries(bundle)) {
-        if (content.type === "chunk") {
-          const virtualModule = {
-            code: content.code,
-            map: null
-          };
-          const maybeMap = bundle[`${fileName}.map`];
-          if (maybeMap && maybeMap.type === "asset") {
-            virtualModule.map = maybeMap.source;
-          }
-          _modules.set(fileName, virtualModule);
-          _modules.set(resolve(fileName), virtualModule);
-        }
-      }
-    }
-    return _modules;
-  };
-  return {
-    name: "virtual-bundle",
-    resolveId(id, importer) {
-      const modules = getModules();
-      if (modules.has(id)) {
-        return resolve(id);
-      }
-      if (importer) {
-        const resolved = resolve(dirname(importer), id);
-        if (modules.has(resolved)) {
-          return resolved;
-        }
-      }
-      return null;
-    },
-    load(id) {
-      const modules = getModules();
-      const m = modules.get(id);
-      if (!m) {
-        return null;
-      }
-      return m;
-    }
-  };
-}
-
-const BuilderNames = {
-  nitro: colors.magenta("Nitro"),
-  client: colors.green("Client"),
-  ssr: colors.blue("SSR")
-};
-async function buildEnvironments(ctx, builder) {
-  const nitro = ctx.nitro;
-  for (const [envName, env] of Object.entries(builder.environments)) {
-    const fmtName = BuilderNames[envName] || (envName.length <= 3 ? envName.toUpperCase() : envName[0].toUpperCase() + envName.slice(1));
-    if (envName === "nitro" || !env.config.build.rollupOptions.input || env.isBuilt) {
-      if (!["nitro", "ssr", "client"].includes(envName)) {
-        nitro.logger.info(
-          env.isBuilt ? `Skipping ${fmtName} (already built)` : `Skipping ${fmtName} (no input defined)`
-        );
-      }
-      continue;
-    }
-    if (!isTest && !isCI) console.log();
-    nitro.logger.start(`Building [${fmtName}]`);
-    await builder.build(env);
-  }
-  const nitroOptions = ctx.nitro.options;
-  const clientInput = builder.environments.client?.config?.build?.rollupOptions?.input;
-  if (nitroOptions.renderer?.template && nitroOptions.renderer?.template === clientInput) {
-    const outputPath = resolve(
-      nitroOptions.output.publicDir,
-      basename(clientInput)
-    );
-    if (existsSync(outputPath)) {
-      const html = await readFile(outputPath, "utf8").then(
-        (r) => r.replace(
-          "<!--ssr-outlet-->",
-          `{{{ fetch($REQUEST, { viteEnv: "ssr" }) }}}`
-        )
-      );
-      await rm(outputPath);
-      const tmp = resolve(nitroOptions.buildDir, "vite/index.html");
-      await mkdir(dirname(tmp), { recursive: true });
-      await writeFile(tmp, html, "utf8");
-      nitroOptions.renderer.template = tmp;
-    }
-  }
-  await builder.writeAssetsManifest?.();
-  if (!isTest && !isCI) console.log();
-  const buildInfo = [
-    ["preset", nitro.options.preset],
-    ["compatibility", formatCompatibilityDate(nitro.options.compatibilityDate)]
-  ].filter((e) => e[1]);
-  nitro.logger.start(
-    `Building [${BuilderNames.nitro}] ${colors.dim(`(${buildInfo.map(([k, v]) => `${k}: \`${v}\``).join(", ")})`)}`
-  );
-  await copyPublicAssets(nitro);
-  await builder.build(builder.environments.nitro);
-  await nitro.close();
-  await nitro.hooks.callHook("compiled", nitro);
-  await writeBuildInfo(nitro);
-  const rOutput = relative(process.cwd(), nitro.options.output.dir);
-  const rewriteRelativePaths = (input) => {
-    return input.replace(/([\s:])\.\/(\S*)/g, `$1${rOutput}/$2`);
-  };
-  if (!isTest && !isCI) console.log();
-  if (nitro.options.commands.preview) {
-    nitro.logger.success(
-      `You can preview this build using \`${rewriteRelativePaths(
-        nitro.options.commands.preview
-      )}\``
-    );
-  }
-  if (nitro.options.commands.deploy) {
-    nitro.logger.success(
-      `You can deploy this build using \`${rewriteRelativePaths(
-        nitro.options.commands.deploy
-      )}\``
-    );
-  }
-}
-function prodSetup(ctx) {
-  const services = ctx.pluginConfig.services || {};
-  const serviceNames = Object.keys(services);
-  const serviceEntries = serviceNames.map((name) => {
-    let entry;
-    if (ctx.pluginConfig.experimental?.virtualBundle) {
-      entry = ctx._entryPoints[name];
-    } else {
-      entry = resolve(
-        ctx.nitro.options.buildDir,
-        "vite/services",
-        name,
-        ctx._entryPoints[name]
-      );
-    }
-    return [name, entry];
-  });
-  return (
-    /* js */
-    `
-import { setupVite } from "${resolve(runtimeDir, "internal/vite/prod-setup.mjs")}";
-
-const manifest = ${JSON.stringify(ctx._manifest || {})};
-
-function lazyService(loader) {
-  let promise, mod
-  return {
-    fetch(req) {
-      if (mod) { return mod.fetch(req) }
-      if (!promise) {
-        promise = loader().then(_mod => (mod = _mod.default || _mod))
-      }
-      return promise.then(mod => mod.fetch(req))
-    }
-  }
-}
-
-const services = {
-${serviceEntries.map(
-      ([name, entry]) => (
-        /* js */
-        `[${JSON.stringify(name)}]: lazyService(() => import(${JSON.stringify(entry)}))`
-      )
-    ).join(",\n")}
-};
-
-setupVite({ manifest, services });
-  `
-  );
-}
-
-function createFetchableDevEnvironment(name, config, devServer, entry) {
-  const transport = createTransport(name, devServer);
-  const context = { hot: true, transport };
-  return new FetchableDevEnvironment(name, config, context, devServer, entry);
-}
-class FetchableDevEnvironment extends DevEnvironment {
-  devServer;
-  constructor(name, config, context, devServer, entry) {
-    super(name, config, context);
-    this.devServer = devServer;
-    this.devServer.sendMessage({
-      type: "custom",
-      event: "nitro:vite-env",
-      data: { name, entry }
-    });
-  }
-  async dispatchFetch(request) {
-    return this.devServer.fetch(request);
-  }
-  async init(...args) {
-    await this.devServer.init?.();
-    return super.init(...args);
-  }
-}
-function createTransport(name, hooks) {
-  const listeners = /* @__PURE__ */ new WeakMap();
-  return {
-    send: (data) => hooks.sendMessage({ ...data, viteEnv: name }),
-    on: (event, handler) => {
-      if (event === "connection") return;
-      const listener = (value) => {
-        if (value?.type === "custom" && value.event === event && value.viteEnv === name) {
-          handler(value.data, {
-            send: (payload) => hooks.sendMessage({ ...payload, viteEnv: name })
-          });
-        }
-      };
-      listeners.set(handler, listener);
-      hooks.onMessage(listener);
-    },
-    off: (event, handler) => {
-      if (event === "connection") return;
-      const listener = listeners.get(handler);
-      if (listener) {
-        hooks.offMessage(listener);
-        listeners.delete(handler);
-      }
-    }
-  };
-}
-async function configureViteDevServer(ctx, server) {
-  const nitro = ctx.nitro;
-  const nitroEnv = server.environments.nitro;
-  const nitroConfigFile = nitro.options._c12.configFile;
-  if (nitroConfigFile) {
-    server.config.configFileDependencies.push(nitroConfigFile);
-  }
-  const reload = debounce(async () => {
-    await scanHandlers(nitro);
-    nitro.routing.sync();
-    nitroEnv.moduleGraph.invalidateAll();
-    nitroEnv.hot.send({ type: "full-reload" });
-  });
-  const scanDirs = nitro.options.scanDirs.flatMap((dir) => [
-    join(dir, nitro.options.apiDir || "api"),
-    join(dir, nitro.options.routesDir || "routes"),
-    join(dir, "middleware"),
-    join(dir, "plugins"),
-    join(dir, "modules")
-  ]);
-  const watchReloadEvents = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir"]);
-  const scanDirsWatcher = watch(scanDirs, {
-    ignoreInitial: true
-  }).on("all", (event, path, stat) => {
-    if (watchReloadEvents.has(event)) {
-      reload();
-    }
-  });
-  const srcDirWatcher = watch$1(
-    nitro.options.srcDir,
-    { persistent: false },
-    (_event, filename) => {
-      if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) {
-        reload();
-      }
-    }
-  );
-  nitro.hooks.hook("close", () => {
-    scanDirsWatcher.close();
-    srcDirWatcher.close();
-  });
-  const hostIPC = {
-    async transformHTML(html) {
-      return server.transformIndexHtml("/", html).then(
-        (r) => r.replace(
-          "<!--ssr-outlet-->",
-          `{{{ fetch($REQUEST, { viteEnv: "ssr" }) }}}`
-        )
-      );
-    }
-  };
-  nitroEnv.devServer.onMessage(async (payload) => {
-    if (payload.type === "custom" && payload.event === "nitro:vite-invoke") {
-      const methodName = payload.data.name;
-      const res = await hostIPC[methodName](payload.data.data).then((data) => ({ data })).catch((error) => ({ error }));
-      nitroEnv.devServer.sendMessage({
-        type: "custom",
-        event: "nitro:vite-invoke-response",
-        data: { id: payload.data.id, data: res }
-      });
-    }
-  });
-  const nitroDevMiddleware = async (nodeReq, nodeRes, next) => {
-    if (/^\/@(?:vite|fs|id)\//.test(nodeReq.url) || nodeReq._nitroHandled) {
-      return next();
-    }
-    nodeReq._nitroHandled = true;
-    const req = new NodeRequest({ req: nodeReq, res: nodeRes });
-    const devAppRes = await ctx.devApp.fetch(req);
-    if (nodeRes.writableEnded || nodeRes.headersSent) {
-      return;
-    }
-    if (devAppRes.status !== 404) {
-      return await sendNodeResponse(nodeRes, devAppRes);
-    }
-    const envRes = await nitroEnv.dispatchFetch(req);
-    if (nodeRes.writableEnded || nodeRes.headersSent) {
-      return;
-    }
-    if (envRes.status !== 404) {
-      return await sendNodeResponse(nodeRes, envRes);
-    }
-    return next();
-  };
-  server.middlewares.use(function nitroDevMiddlewarePre(req, res, next) {
-    const fetchDest = req.headers["sec-fetch-dest"];
-    if (fetchDest) {
-      res.setHeader("vary", "sec-fetch-dest");
-    }
-    const ext = (req.url || "").match(/\.([a-z0-9]+)(?:[?#]|$)/i)?.[1] || "";
-    if (!ext && (!fetchDest || /^(document|iframe|frame|empty)$/.test(fetchDest))) {
-      nitroDevMiddleware(req, res, next);
-    } else {
-      next();
-    }
-  });
-  return () => {
-    server.middlewares.use(nitroDevMiddleware);
-  };
-}
-
-function createDevWorker(ctx) {
-  return new NodeDevWorker({
-    name: "nitro-vite",
-    entry: resolve$1(runtimeDir, "internal/vite/dev-worker.mjs"),
-    hooks: {},
-    data: {
-      server: true,
-      globals: {
-        __NITRO_RUNTIME_CONFIG__: ctx.nitro.options.runtimeConfig
-      }
-    }
-  });
-}
-function createNitroEnvironment(ctx) {
-  return {
-    consumer: "server",
-    build: {
-      rollupOptions: ctx.rollupConfig.config,
-      minify: ctx.nitro.options.minify,
-      emptyOutDir: false,
-      commonjsOptions: {
-        strictRequires: "auto",
-        // TODO: set to true (default) in v3
-        esmExternals: (id) => !id.startsWith("unenv/"),
-        requireReturnsDefault: "auto",
-        ...ctx.nitro.options.commonJS
-      }
-    },
-    resolve: {
-      noExternal: ctx.nitro.options.dev ? (
-        // Workaround for dev: external dependencies are not resolvable with respect to nodeModulePaths
-        new RegExp(runtimeDependencies.join("|"))
-      ) : void 0,
-      conditions: ctx.nitro.options.exportConditions,
-      externalConditions: ctx.nitro.options.exportConditions
-    },
-    dev: {
-      createEnvironment: (envName, envConfig) => createFetchableDevEnvironment(
-        envName,
-        envConfig,
-        ctx.devWorker,
-        resolve$1(runtimeDir, "internal/vite/dev-entry.mjs")
-      )
-    }
-  };
-}
-function createServiceEnvironment(ctx, name, serviceConfig) {
-  return {
-    consumer: "server",
-    build: {
-      rollupOptions: { input: serviceConfig.entry },
-      minify: ctx.nitro.options.minify,
-      outDir: join$1(ctx.nitro.options.buildDir, "vite", "services", name),
-      emptyOutDir: true
-    },
-    resolve: {
-      conditions: ctx.nitro.options.exportConditions,
-      externalConditions: ctx.nitro.options.exportConditions
-    },
-    dev: {
-      createEnvironment: (envName, envConfig) => createFetchableDevEnvironment(
-        envName,
-        envConfig,
-        ctx.devWorker,
-        tryResolve(serviceConfig.entry)
-      )
-    }
-  };
-}
-function createServiceEnvironments(ctx) {
-  return Object.fromEntries(
-    Object.entries(ctx.pluginConfig.services || {}).map(([name, config]) => [
-      name,
-      createServiceEnvironment(ctx, name, config)
-    ])
-  );
-}
-function tryResolve(id) {
-  if (/^[~#/\0]/.test(id) || isAbsolute(id)) {
-    return id;
-  }
-  const resolved = resolveModulePath(id, {
-    suffixes: ["", "/index"],
-    extensions: ["", ".ts", ".mjs", ".cjs", ".js", ".mts", ".cts"],
-    try: true
-  });
-  return resolved || id;
-}
-
-function nitroPreviewPlugin(ctx) {
-  return {
-    name: "nitro:preview",
-    apply: (_config, configEnv) => !!configEnv.isPreview,
-    config(config) {
-      return {
-        preview: {
-          port: config.preview?.port || 3e3
-        }
-      };
-    },
-    async configurePreviewServer(server) {
-      const buildInfoPath = resolve(
-        server.config.root,
-        "node_modules/.nitro/last-build",
-        "nitro.json"
-      );
-      if (!existsSync(buildInfoPath)) {
-        console.warn(
-          `[nitro] No build found. Please build your project before previewing.`
-        );
-        return;
-      }
-      const realBuildDir = await readlink("node_modules/.nitro/last-build");
-      const buildInfo = JSON.parse(
-        await readFile(buildInfoPath, "utf8")
-      );
-      const info = [
-        ["Build Directory:", prettyPath(realBuildDir)],
-        ["Date:", buildInfo.date && new Date(buildInfo.date).toLocaleString()],
-        ["Nitro Version:", buildInfo.versions.nitro],
-        ["Nitro Preset:", buildInfo.preset],
-        buildInfo.framework?.name !== "nitro" && [
-          "Framework:",
-          buildInfo.framework?.name + (buildInfo.framework?.version ? ` (v${buildInfo.framework.version})` : "")
-        ]
-      ].filter((i) => i && i[1]);
-      consola.box({
-        title: " [Build Info] ",
-        message: info.map((i) => `- ${i[0]} ${i[1]}`).join("\n")
-      });
-      if (!buildInfo.commands?.preview) {
-        consola.warn("[nitro] No preview command found for this preset..");
-        return;
-      }
-      const randomPort = await getRandomPort();
-      consola.info(`Spawning preview server...`);
-      const [command, ...args] = buildInfo.commands.preview.split(" ");
-      let child;
-      consola.info(buildInfo.commands?.preview);
-      child = spawn(command, args, {
-        stdio: "inherit",
-        cwd: realBuildDir,
-        env: {
-          ...process.env,
-          PORT: String(randomPort)
-        }
-      });
-      process.on("exit", () => {
-        child?.kill();
-        child = void 0;
-      });
-      child.on("exit", (code) => {
-        if (code && code !== 0) {
-          consola.error(`[nitro] Preview server exited with code ${code}`);
-        }
-      });
-      const proxy = createProxyServer({
-        target: `http://localhost:${randomPort}`
-      });
-      server.middlewares.use((req, res, next) => {
-        if (child && !child.killed) {
-          proxy.web(req, res).catch(next);
-        } else {
-          res.end(`Nitro preview server is not running.`);
-        }
-      });
-    }
-  };
-}
-
-//#region src/plugins/shared.ts
-function parseIdQuery(id) {
-	if (!id.includes("?")) return {
-		filename: id,
-		query: {}
-	};
-	const [filename, rawQuery] = id.split(`?`, 2);
-	const query = Object.fromEntries(new URLSearchParams(rawQuery));
-	return {
-		filename,
-		query
-	};
-}
-function toAssetsVirtual(options) {
-	return `virtual:fullstack/assets?${new URLSearchParams(options)}&lang.js`;
-}
-function parseAssetsVirtual(id) {
-	if (id.startsWith("\0virtual:fullstack/assets?")) return parseIdQuery(id).query;
-}
-
-//#endregion
-//#region src/plugins/utils.ts
-function createVirtualPlugin(name, load) {
-	name = "virtual:" + name;
-	return {
-		name: `rsc:virtual-${name}`,
-		resolveId: { handler(source, _importer, _options) {
-			return source === name ? "\0" + name : void 0;
-		} },
-		load: { handler(id, options) {
-			if (id === "\0" + name) return load.apply(this, [id, options]);
-		} }
-	};
-}
-function normalizeRelativePath(s) {
-	s = normalizePath(s);
-	return s[0] === "." ? s : "./" + s;
-}
-function hashString(v) {
-	return createHash("sha256").update(v).digest().toString("hex").slice(0, 12);
-}
-
-//#endregion
-//#region src/plugins/vite-utils.ts
-const VALID_ID_PREFIX = `/@id/`;
-const NULL_BYTE_PLACEHOLDER = `__x00__`;
-const FS_PREFIX = `/@fs/`;
-function wrapId(id) {
-	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
-}
-function withTrailingSlash(path$1) {
-	if (path$1[path$1.length - 1] !== "/") return `${path$1}/`;
-	return path$1;
-}
-const postfixRE = /[?#].*$/;
-function cleanUrl(url) {
-	return url.replace(postfixRE, "");
-}
-function splitFileAndPostfix(path$1) {
-	const file = cleanUrl(path$1);
-	return {
-		file,
-		postfix: path$1.slice(file.length)
-	};
-}
-const windowsSlashRE = /\\/g;
-function slash(p) {
-	return p.replace(windowsSlashRE, "/");
-}
-const isWindows = typeof process !== "undefined" && process.platform === "win32";
-function injectQuery(url, queryToInject) {
-	const { file, postfix } = splitFileAndPostfix(url);
-	const normalizedFile = isWindows ? slash(file) : file;
-	return `${normalizedFile}?${queryToInject}${postfix[0] === "?" ? `&${postfix.slice(1)}` : postfix}`;
-}
-function normalizeResolvedIdToUrl(environment, url, resolved) {
-	const root = environment.config.root;
-	const depsOptimizer = environment.depsOptimizer;
-	if (resolved.id.startsWith(withTrailingSlash(root))) url = resolved.id.slice(root.length);
-	else if (depsOptimizer?.isOptimizedDepFile(resolved.id) || resolved.id !== "/@react-refresh" && path.isAbsolute(resolved.id) && fs.existsSync(cleanUrl(resolved.id))) url = path.posix.join(FS_PREFIX, resolved.id);
-	else url = resolved.id;
-	if (url[0] !== "." && url[0] !== "/") url = wrapId(resolved.id);
-	return url;
-}
-function normalizeViteImportAnalysisUrl(environment, id) {
-	let url = normalizeResolvedIdToUrl(environment, id, { id });
-	if (environment.config.consumer === "client") {
-		const mod = environment.moduleGraph.getModuleById(id);
-		if (mod && mod.lastHMRTimestamp > 0) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
-	}
-	return url;
-}
-function evalValue(rawValue) {
-	const fn = new Function(`
-    var console, exports, global, module, process, require
-    return (\n${rawValue}\n)
-  `);
-	return fn();
-}
-const directRequestRE = /(\?|&)direct=?(?:&|$)/;
-function assetsPlugin(pluginOpts) {
-	let server;
-	let resolvedConfig;
-	const importAssetsMetaMap = {};
-	const bundleMap = {};
-	async function processAssetsImport(ctx, id, options) {
-		if (ctx.environment.mode === "dev") {
-			const result = {
-				entry: void 0,
-				js: [],
-				css: []
-			};
-			const environment = server.environments[options.environment];
-			assert(environment, `Unknown environment: ${options.environment}`);
-			if (options.environment === "client") result.entry = normalizeViteImportAnalysisUrl(environment, id);
-			if (environment.name !== "client") {
-				const collected = await collectCss(environment, id, { eager: pluginOpts?.experimental?.devEagerTransform ?? true });
-				result.css = collected.hrefs.map((href, i) => ({
-					href,
-					"data-vite-dev-id": collected.ids[i]
-				}));
-			}
-			return JSON.stringify(result);
-		} else {
-			const map = importAssetsMetaMap[options.environment] ??= {};
-			const meta = {
-				id,
-				key: path.relative(resolvedConfig.root, id),
-				importerEnvironment: ctx.environment.name,
-				isEntry: !!(map[id]?.isEntry || options.isEntry)
-			};
-			map[id] = meta;
-			return `__assets_manifest[${JSON.stringify(options.environment)}][${JSON.stringify(meta.key)}]`;
-		}
-	}
-	let writeAssetsManifestCalled = false;
-	async function writeAssetsManifest(builder) {
-		if (writeAssetsManifestCalled) return;
-		writeAssetsManifestCalled = true;
-		const manifest = {};
-		for (const [environmentName, metas] of Object.entries(importAssetsMetaMap)) {
-			const bundle = bundleMap[environmentName];
-			const assetDepsMap = collectAssetDeps(bundle);
-			for (const [id, meta] of Object.entries(metas)) {
-				const found = assetDepsMap[id];
-				if (!found) {
-					builder.config.logger.error(`[vite-plugin-fullstack] failed to find built chunk for ${meta.id} imported by ${meta.importerEnvironment} environment`);
-					return;
-				}
-				const result = {
-					js: [],
-					css: []
-				};
-				const { chunk, deps } = found;
-				if (environmentName === "client") {
-					result.entry = `/${chunk.fileName}`;
-					result.js = deps.js.map((fileName) => ({ href: `/${fileName}` }));
-				}
-				result.css = deps.css.map((fileName) => ({ href: `/${fileName}` }));
-				if (!builder.environments[environmentName].config.build.cssCodeSplit) {
-					const singleCss = Object.values(bundle).find((v) => v.type === "asset" && v.originalFileNames.includes("style.css"));
-					if (singleCss) result.css.push({ href: `/${singleCss.fileName}` });
-				}
-				(manifest[environmentName] ??= {})[meta.key] = result;
-			}
-		}
-		const importerEnvironments = new Set(Object.values(importAssetsMetaMap).flatMap((metas) => Object.values(metas)).flatMap((meta) => meta.importerEnvironment));
-		for (const environmentName of importerEnvironments) {
-			const outDir = builder.environments[environmentName].config.build.outDir;
-			fs.writeFileSync(path.join(outDir, BUILD_ASSETS_MANIFEST_NAME), `export default ${JSON.stringify(manifest, null, 2)};`);
-			const clientOutDir = builder.environments["client"].config.build.outDir;
-			for (const asset of Object.values(bundleMap[environmentName])) if (asset.type === "asset") {
-				const srcFile = path.join(outDir, asset.fileName);
-				const destFile = path.join(clientOutDir, asset.fileName);
-				fs.mkdirSync(path.dirname(destFile), { recursive: true });
-				fs.copyFileSync(srcFile, destFile);
-			}
-		}
-	}
-	return [
-		{
-			name: "fullstack:assets",
-			sharedDuringBuild: true,
-			configureServer(server_) {
-				server = server_;
-			},
-			configResolved(config) {
-				resolvedConfig = config;
-			},
-			configEnvironment(name) {
-				const serverEnvironments = pluginOpts?.serverEnvironments ?? ["ssr"];
-				if (serverEnvironments.includes(name)) return { build: { emitAssets: true } };
-			},
-			transform: { async handler(code, id, _options) {
-				if (!code.includes("import.meta.vite.assets")) return;
-				const output = new MagicString(code);
-				const strippedCode = stripLiteral(code);
-				const newImports = /* @__PURE__ */ new Set();
-				for (const match of code.matchAll(/import\.meta\.vite\.assets\(([\s\S]*?)\)/dg)) {
-					const [start, end] = match.indices[0];
-					if (!strippedCode.slice(start, end).includes("import.meta.vite.assets")) continue;
-					if (this.environment.name === "client") {
-						const replacement$1 = `(${JSON.stringify(EMPTY_ASSETS)})`;
-						output.update(start, end, replacement$1);
-						continue;
-					}
-					const argCode = match[1].trim();
-					const options = {
-						import: id,
-						environment: void 0,
-						asEntry: false
-					};
-					if (argCode) {
-						const argValue = evalValue(argCode);
-						Object.assign(options, argValue);
-					}
-					const environments = options.environment ? [options.environment] : ["client", this.environment.name];
-					const importedNames = [];
-					for (const environment of environments) {
-						const importSource = toAssetsVirtual({
-							import: options.import,
-							importer: id,
-							environment,
-							entry: options.asEntry ? "1" : ""
-						});
-						const hash = hashString(importSource);
-						const importedName = `__assets_${hash}`;
-						newImports.add(`;import ${importedName} from ${JSON.stringify(importSource)};\n`);
-						importedNames.push(importedName);
-					}
-					let replacement = importedNames[0];
-					if (importedNames.length > 1) {
-						newImports.add(`;import * as __assets_runtime from "virtual:fullstack/runtime";\n`);
-						replacement = `__assets_runtime.mergeAssets(${importedNames.join(", ")})`;
-					}
-					output.update(start, end, `(${replacement})`);
-				}
-				if (output.hasChanged()) {
-					for (const newImport of newImports) output.append(newImport);
-					return {
-						code: output.toString(),
-						map: output.generateMap({ hires: "boundary" })
-					};
-				}
-			} },
-			resolveId: { handler(source) {
-				if (source.startsWith("virtual:fullstack/assets?")) return "\0" + source;
-				if (source === "virtual:fullstack/assets-manifest") {
-					assert.notEqual(this.environment.name, "client");
-					assert.equal(this.environment.mode, "build");
-					return {
-						id: source,
-						external: true
-					};
-				}
-				if (source === "virtual:fullstack/runtime") return { id: source };
-			} },
-			load: { async handler(id) {
-				if (id === "virtual:fullstack/runtime") return runtimeUtils();
-				const parsed = parseAssetsVirtual(id);
-				if (!parsed) return;
-				assert.notEqual(this.environment.name, "client");
-				const resolved = await this.resolve(parsed.import, parsed.importer);
-				assert(resolved, `Failed to resolve: ${parsed.import}`);
-				const s = new MagicString("");
-				const code = await processAssetsImport(this, resolved.id, {
-					environment: parsed.environment,
-					isEntry: !!parsed.entry
-				});
-				s.append(`export default ${code};\n`);
-				if (this.environment.mode === "build") s.prepend(`import __assets_manifest from "virtual:fullstack/assets-manifest";\n`);
-				return s.toString();
-			} },
-			renderChunk(code, chunk) {
-				if (code.includes("virtual:fullstack/assets-manifest")) {
-					const replacement = normalizeRelativePath(path.relative(path.join(chunk.fileName, ".."), BUILD_ASSETS_MANIFEST_NAME));
-					code = code.replaceAll("virtual:fullstack/assets-manifest", () => replacement);
-					return { code };
-				}
-				return;
-			},
-			writeBundle(_options, bundle) {
-				bundleMap[this.environment.name] = bundle;
-			},
-			buildStart() {
-				if (this.environment.mode == "build" && this.environment.name === "client") {
-					const metas = importAssetsMetaMap["client"];
-					if (metas) {
-						for (const meta of Object.values(importAssetsMetaMap["client"])) if (meta.isEntry) this.emitFile({
-							type: "chunk",
-							id: meta.id,
-							preserveSignature: "exports-only"
-						});
-					}
-				}
-			},
-			buildApp: {
-				order: "pre",
-				async handler(builder) {
-					builder.writeAssetsManifest = async () => {
-						await writeAssetsManifest(builder);
-					};
-				}
-			}
-		},
-		{
-			name: "fullstack:write-assets-manifest-post",
-			buildApp: {
-				order: "post",
-				async handler(builder) {
-					await builder.writeAssetsManifest();
-				}
-			}
-		},
-		{
-			name: "fullstack:assets-query",
-			sharedDuringBuild: true,
-			resolveId: {
-				order: "pre",
-				handler(source) {
-					const { query } = parseIdQuery(source);
-					const value = query["assets"];
-					if (typeof value !== "undefined") {
-						if (this.environment.name === "client") return `\0virtual:fullstack/empty-assets`;
-					}
-					if (source === "virtual:fullstack/runtime") return source;
-				}
-			},
-			load: { async handler(id) {
-				if (id === "\0virtual:fullstack/empty-assets") return `export default ${JSON.stringify(EMPTY_ASSETS)}`;
-				if (id === "virtual:fullstack/runtime") return runtimeUtils();
-				const { filename, query } = parseIdQuery(id);
-				const value = query["assets"];
-				if (typeof value !== "undefined") {
-					const s = new MagicString("");
-					const codes = [];
-					if (value) {
-						const code = await processAssetsImport(this, filename, {
-							environment: value,
-							isEntry: value === "client"
-						});
-						codes.push(code);
-					} else {
-						const code1 = await processAssetsImport(this, filename, {
-							environment: "client",
-							isEntry: false
-						});
-						const code2 = await processAssetsImport(this, filename, {
-							environment: this.environment.name,
-							isEntry: false
-						});
-						codes.push(code1, code2);
-					}
-					s.append(`
-import * as __assets_runtime from "virtual:fullstack/runtime";\n
-export default __assets_runtime.mergeAssets(${codes.join(", ")});
-`);
-					if (this.environment.mode === "build") s.prepend(`import __assets_manifest from "virtual:fullstack/assets-manifest";\n`);
-					return {
-						code: s.toString(),
-						moduleSideEffects: false
-					};
-				}
-			} },
-			hotUpdate(ctx) {
-				if (this.environment.name === "rsc") {
-					const mods = collectModuleDependents(ctx.modules);
-					for (const mod of mods) if (mod.id) {
-						const ids = [
-							`${mod.id}?assets`,
-							`${mod.id}?assets=client`,
-							`${mod.id}?assets=${this.environment.name}`
-						];
-						for (const id of ids) invalidteModuleById(this.environment, id);
-					}
-				}
-			}
-		},
-		{
-			...createVirtualPlugin("fullstack/client-fallback", () => "export {}"),
-			configEnvironment: {
-				order: "post",
-				handler(name, config, _env) {
-					if (name === "client") {
-						const clientBuildFallback = pluginOpts?.experimental?.clientBuildFallback ?? true;
-						if (clientBuildFallback && !config.build?.rollupOptions?.input) return { build: { rollupOptions: { input: { __fallback: "virtual:fullstack/client-fallback" } } } };
-					}
-				}
-			},
-			generateBundle(_optoins, bundle) {
-				if (this.environment.name !== "client") return;
-				for (const [k, v] of Object.entries(bundle)) if (v.type === "chunk" && v.name === "__fallback") delete bundle[k];
-			}
-		},
-		patchViteClientPlugin(),
-		patchVueScopeCssHmr(),
-		patchCssLinkSelfAccept()
-	];
-}
-const EMPTY_ASSETS = {
-	js: [],
-	css: []
-};
-const BUILD_ASSETS_MANIFEST_NAME = "__fullstack_assets_manifest.js";
-async function collectCss(environment, entryId, options) {
-	const visited = /* @__PURE__ */ new Set();
-	const cssIds = /* @__PURE__ */ new Set();
-	async function recurse(id) {
-		if (visited.has(id) || parseAssetsVirtual(id) || "assets" in parseIdQuery(id).query) return;
-		visited.add(id);
-		const mod = environment.moduleGraph.getModuleById(id);
-		if (!mod) return;
-		if (options.eager && !mod?.transformResult) try {
-			await environment.transformRequest(id);
-		} catch (e) {
-			console.error(`[collectCss] Failed to transform '${id}'`, e);
-		}
-		for (const next of mod?.importedModules ?? []) if (next.id) if (isCSSRequest(next.id)) {
-			if (hasSpecialCssQuery(next.id)) continue;
-			cssIds.add(next.id);
-		} else await recurse(next.id);
-	}
-	await recurse(entryId);
-	const hrefs = [...cssIds].map((id) => normalizeViteImportAnalysisUrl(environment, id));
-	return {
-		ids: [...cssIds],
-		hrefs
-	};
-}
-function invalidteModuleById(environment, id) {
-	const mod = environment.moduleGraph.getModuleById(id);
-	if (mod) environment.moduleGraph.invalidateModule(mod);
-	return mod;
-}
-function collectModuleDependents(mods) {
-	const visited = /* @__PURE__ */ new Set();
-	function recurse(mod) {
-		if (visited.has(mod)) return;
-		visited.add(mod);
-		for (const importer of mod.importers) recurse(importer);
-	}
-	for (const mod of mods) recurse(mod);
-	return [...visited];
-}
-function hasSpecialCssQuery(id) {
-	return /[?&](url|inline|raw)(\b|=|&|$)/.test(id);
-}
-function collectAssetDeps(bundle) {
-	const chunkToDeps = /* @__PURE__ */ new Map();
-	for (const chunk of Object.values(bundle)) if (chunk.type === "chunk") chunkToDeps.set(chunk, collectAssetDepsInner(chunk.fileName, bundle));
-	const idToDeps = {};
-	for (const [chunk, deps] of chunkToDeps.entries()) for (const id of chunk.moduleIds) idToDeps[id] = {
-		chunk,
-		deps
-	};
-	return idToDeps;
-}
-function collectAssetDepsInner(fileName, bundle) {
-	const visited = /* @__PURE__ */ new Set();
-	const css = [];
-	function recurse(k) {
-		if (visited.has(k)) return;
-		visited.add(k);
-		const v = bundle[k];
-		assert(v, `Not found '${k}' in the bundle`);
-		if (v.type === "chunk") {
-			css.push(...v.viteMetadata?.importedCss ?? []);
-			for (const k2 of v.imports) if (k2 in bundle) recurse(k2);
-		}
-	}
-	recurse(fileName);
-	return {
-		js: [...visited],
-		css: [...new Set(css)]
-	};
-}
-function patchViteClientPlugin() {
-	const viteClientPath = normalizePath(fileURLToPath(import.meta.resolve("vite/dist/client/client.mjs")));
-	function endIndexOf(code, searchValue) {
-		const i = code.lastIndexOf(searchValue);
-		return i === -1 ? i : i + searchValue.length;
-	}
-	return {
-		name: "fullstack:patch-vite-client",
-		transform: { handler(code, id) {
-			if (id === viteClientPath) {
-				if (code.includes("linkSheetsMap")) return;
-				const s = new MagicString(code);
-				s.prependLeft(code.indexOf("const sheetsMap"), `\
-const linkSheetsMap = new Map();
-document
-  .querySelectorAll('link[rel="stylesheet"][data-vite-dev-id]')
-  .forEach((el) => {
-    linkSheetsMap.set(el.getAttribute('data-vite-dev-id'), el)
-  });
-`);
-				s.appendLeft(endIndexOf(code, `function updateStyle(id, content) {`), `if (linkSheetsMap.has(id)) { return }`);
-				s.appendLeft(endIndexOf(code, `function removeStyle(id) {`), `
-const link = linkSheetsMap.get(id);
-if (link) {
-  document
-    .querySelectorAll(
-      'link[rel="stylesheet"][data-vite-dev-id]',
-    )
-    .forEach((el) => {
-      if (el.getAttribute('data-vite-dev-id') === id) {
-        el.remove()
-      }
-    })
-  linkSheetsMap.delete(id)
-}
-`);
-				return s.toString();
-			}
-		} }
-	};
-}
-function patchVueScopeCssHmr() {
-	return {
-		name: "fullstack:patch-vue-scoped-css-hmr",
-		configureServer(server) {
-			server.middlewares.use((req, _res, next) => {
-				if (req.headers.accept?.includes("text/css") && req.url?.includes("&lang.css=")) req.url = req.url.replace("&lang.css=", "?lang.css");
-				next();
-			});
-		}
-	};
-}
-function patchCssLinkSelfAccept() {
-	return {
-		name: "fullstack:patch-css-link-self-accept",
-		apply: "serve",
-		transform: {
-			order: "post",
-			handler(_code, id, _options) {
-				if (this.environment.name === "client" && this.environment.mode === "dev" && isCSSRequest(id) && directRequestRE.test(id)) {
-					const mod = this.environment.moduleGraph.getModuleById(id);
-					if (mod && !mod.isSelfAccepting) mod.isSelfAccepting = true;
-				}
-			}
-		}
-	};
-}
-function runtimeUtils() {
-	return `
-export function mergeAssets(...args) {
-  const js = uniqBy(args.flatMap((h) => h.js), (a) => a.href);
-  const css = uniqBy(args.flatMap((h) => h.css), (a) => a.href);
-  const entry = args.filter((arg) => arg.entry)?.[0]?.entry;
-  const raw = { entry, js, css };
-  return { ...raw, merge: (...args$1) => mergeAssets(raw, ...args$1) };
-}
-function uniqBy(array, key) {
-  const seen = new Set();
-  return array.filter((item) => {
-    const k = key(item);
-    if (seen.has(k)) return false;
-    seen.add(k);
-    return true;
-  });
-}`;
-}
-
-const DEFAULT_EXTENSIONS = [".ts", ".js", ".mts", ".mjs", ".tsx", ".jsx"];
-const debug = process.env.NITRO_DEBUG ? (...args) => console.log("[nitro]", ...args) : () => {
-};
-function nitro(pluginConfig = {}) {
-  const ctx = createContext(pluginConfig);
-  return [
-    nitroInit(ctx),
-    nitroEnv(ctx),
-    nitroMain(ctx),
-    nitroPrepare(ctx),
-    nitroService(ctx),
-    nitroPreviewPlugin(),
-    pluginConfig.experimental?.assetsImport !== false && assetsPlugin({
-      experimental: {
-        // See https://github.com/hi-ogawa/vite-plugins/pull/1289
-        clientBuildFallback: false
-      }
-    })
-  ];
-}
-function nitroInit(ctx) {
-  return {
-    name: "nitro:init",
-    sharedDuringBuild: true,
-    apply: (_config, configEnv) => !configEnv.isPreview,
-    async config(config, configEnv) {
-      if (!ctx._initialized) {
-        debug("[init] Initializing nitro");
-        ctx._initialized = true;
-        await setupNitroContext(ctx, configEnv, config);
-      }
-    },
-    applyToEnvironment(env) {
-      if (env.name === "nitro" && ctx.nitro?.options.dev) {
-        debug("[init] Adding rollup plugins for dev");
-        return [...ctx.rollupConfig?.config.plugins || []];
-      }
-    }
-  };
-}
-function nitroEnv(ctx) {
-  return {
-    name: "nitro:env",
-    sharedDuringBuild: true,
-    apply: (_config, configEnv) => !configEnv.isPreview,
-    async config(userConfig, _configEnv) {
-      debug("[env]  Extending config (environments)");
-      const environments = {
-        ...createServiceEnvironments(ctx),
-        nitro: createNitroEnvironment(ctx)
-      };
-      environments.client = {
-        consumer: userConfig.environments?.client?.consumer ?? "client",
-        build: {
-          rollupOptions: {
-            input: userConfig.environments?.client?.build?.rollupOptions?.input ?? useNitro(ctx).options.renderer?.template
-          }
-        }
-      };
-      debug("[env]  Environments:", Object.keys(environments).join(", "));
-      return {
-        environments
-      };
-    },
-    configEnvironment(name, config) {
-      if (config.consumer === "client") {
-        debug(
-          "[env]  Configuring client environment",
-          name === "client" ? "" : ` (${name})`
-        );
-        config.build.emptyOutDir = false;
-        config.build.outDir = useNitro(ctx).options.output.publicDir;
-      } else {
-        if (ctx.pluginConfig.experimental?.virtualBundle && name in (ctx.pluginConfig.services || {})) {
-          debug("[env]  Configuring service environment for virtual:", name);
-          config.build ??= {};
-          config.build.write = config.build.write ?? false;
-        }
-      }
-    }
-  };
-}
-function nitroMain(ctx) {
-  return {
-    name: "nitro:main",
-    sharedDuringBuild: true,
-    apply: (_config, configEnv) => !configEnv.isPreview,
-    async config(userConfig, _configEnv) {
-      debug("[main] Extending config (appType, resolve, server)");
-      if (!ctx.rollupConfig) {
-        throw new Error("Nitro rollup config is not initialized yet.");
-      }
-      return {
-        appType: userConfig.appType || "custom",
-        resolve: {
-          // TODO: environment specific aliases not working
-          // https://github.com/vitejs/vite/pull/17583 (seems not effective)
-          alias: ctx.rollupConfig.base.aliases
-        },
-        builder: {
-          sharedConfigBuild: true
-        },
-        server: {
-          port: Number.parseInt(process.env.PORT || "") || userConfig.server?.port || useNitro(ctx).options.devServer?.port || 3e3
-        }
-      };
-    },
-    configResolved(config) {
-      if (config.command === "build") {
-        debug("[main] Inferring caching routes");
-        for (const env of Object.values(config.environments)) {
-          if (env.consumer === "client") {
-            const rule = ctx.nitro.options.routeRules[`/${env.build.assetsDir}/**`] ??= {};
-            if (!rule.headers?.["cache-control"]) {
-              rule.headers = {
-                ...rule.headers,
-                "cache-control": `public, max-age=31536000, immutable`
-              };
-            }
-          }
-        }
-      }
-      debug("[main] Syncing nitro routes");
-      ctx.nitro.routing.sync();
-    },
-    buildApp: {
-      order: "post",
-      handler(builder) {
-        debug("[main] Building environments");
-        return buildEnvironments(ctx, builder);
-      }
-    },
-    generateBundle: {
-      handler(_options, bundle) {
-        const environment = this.environment;
-        debug(
-          "[main] Generating manifest and entry points for environment:",
-          environment.name
-        );
-        const { root } = environment.config;
-        const services = ctx.pluginConfig.services || {};
-        const serviceNames = Object.keys(services);
-        const isRegisteredService = serviceNames.includes(environment.name);
-        let entryFile;
-        for (const [_name, file] of Object.entries(bundle)) {
-          if (file.type === "chunk") {
-            if (isRegisteredService && file.isEntry) {
-              if (entryFile === void 0) {
-                entryFile = file.fileName;
-              } else {
-                this.warn(
-                  `Multiple entry points found for service "${environment.name}"`
-                );
-              }
-            }
-            const filteredModuleIds = file.moduleIds.filter(
-              (id) => id.startsWith(root)
-            );
-            for (const id of filteredModuleIds) {
-              const originalFile = relative(root, id);
-              ctx._manifest[originalFile] = { file: file.fileName };
-            }
-          }
-        }
-        if (isRegisteredService) {
-          if (entryFile === void 0) {
-            this.error(
-              `No entry point found for service "${this.environment.name}".`
-            );
-          }
-          ctx._entryPoints[this.environment.name] = entryFile;
-          ctx._serviceBundles[this.environment.name] = bundle;
-        }
-      }
-    },
-    configureServer: (server) => {
-      debug("[main] Configuring dev server");
-      return configureViteDevServer(ctx, server);
-    }
-  };
-}
-function nitroPrepare(ctx) {
-  return {
-    name: "nitro:prepare",
-    sharedDuringBuild: true,
-    applyToEnvironment: (env) => env.name === "nitro",
-    buildApp: {
-      // Clean the output directory before any environment is built
-      order: "pre",
-      async handler() {
-        debug("[prepare] Preparing output directory");
-        const nitro2 = ctx.nitro;
-        await prepare(nitro2);
-      }
-    }
-  };
-}
-function nitroService(ctx) {
-  return {
-    name: "nitro:service",
-    enforce: "pre",
-    sharedDuringBuild: true,
-    applyToEnvironment: (env) => env.name === "nitro",
-    resolveId: {
-      async handler(id, 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 createContext(pluginConfig) {
-  return {
-    pluginConfig,
-    _entryPoints: {},
-    _manifest: {},
-    _serviceBundles: {}
-  };
-}
-function useNitro(ctx) {
-  if (!ctx.nitro) {
-    throw new Error("Nitro instance is not initialized yet.");
-  }
-  return ctx.nitro;
-}
-async function setupNitroContext(ctx, configEnv, userConfig) {
-  ctx.nitro = ctx.pluginConfig._nitro || await createNitro({
-    dev: configEnv.mode === "development",
-    rootDir: userConfig.root,
-    ...defu(ctx.pluginConfig.config, userConfig.nitro)
-  });
-  if (!ctx.pluginConfig.services?.ssr) {
-    ctx.pluginConfig.services ??= {};
-    if (userConfig.environments?.ssr === void 0) {
-      const ssrEntry = resolveModulePath("./entry-server", {
-        from: ["", "app", "src"].flatMap(
-          (d) => ctx.nitro.options.scanDirs.map((s) => join(s, d) + "/")
-        ),
-        extensions: DEFAULT_EXTENSIONS,
-        try: true
-      });
-      if (ssrEntry) {
-        ctx.pluginConfig.services.ssr = { entry: ssrEntry };
-        ctx.nitro.logger.info(
-          `Using \`${prettyPath(ssrEntry)}\` as vite ssr entry.`
-        );
-      }
-    } else {
-      let ssrEntry = getEntry(
-        userConfig.environments.ssr.build?.rollupOptions?.input
-      );
-      if (typeof ssrEntry === "string") {
-        ssrEntry = resolveModulePath(ssrEntry, {
-          from: ctx.nitro.options.scanDirs,
-          extensions: DEFAULT_EXTENSIONS,
-          suffixes: ["", "/index"],
-          try: true
-        }) || ssrEntry;
-        ctx.pluginConfig.services.ssr = { entry: ssrEntry };
-      } else {
-        throw new TypeError(`Invalid input type for SSR entry point.`);
-      }
-    }
-  }
-  if (!ctx.nitro.options.renderer?.entry && !ctx.nitro.options.renderer?.template && ctx.pluginConfig.services.ssr?.entry) {
-    ctx.nitro.options.renderer ??= {};
-    ctx.nitro.options.renderer.entry = resolve(
-      runtimeDir,
-      "internal/vite/ssr-renderer"
-    );
-  }
-  const publicDistDir = ctx._publicDistDir = userConfig.build?.outDir || resolve(ctx.nitro.options.buildDir, "vite/public");
-  ctx.nitro.options.publicAssets.push({
-    dir: publicDistDir,
-    maxAge: 0,
-    baseURL: "/",
-    fallthrough: true
-  });
-  if (!ctx.nitro.options.dev) {
-    ctx.nitro.options.unenv.push({
-      meta: { name: "nitro-vite" },
-      polyfill: ["#nitro-vite-setup"]
-    });
-  }
-  await ctx.nitro.hooks.callHook("build:before", ctx.nitro);
-  ctx.rollupConfig = await getViteRollupConfig(ctx);
-  await ctx.nitro.hooks.callHook(
-    "rollup:before",
-    ctx.nitro,
-    ctx.rollupConfig.config
-  );
-  if (ctx.nitro.options.dev && !ctx.devWorker) {
-    ctx.devWorker = createDevWorker(ctx);
-  }
-  if (ctx.nitro.options.dev && !ctx.devApp) {
-    ctx.devApp = new NitroDevApp(ctx.nitro);
-  }
-}
-function getEntry(input) {
-  if (typeof input === "string") {
-    return input;
-  } else if (Array.isArray(input) && input.length > 0) {
-    return input[0];
-  } else if (input && "index" in input) {
-    return input.index;
-  }
-}
-
-export { nitro as n };