@nuxt/vite-server-nightly 0.0.0 → 5.0.0-29802883.a46ecec7

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-present - Nuxt Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+<a href="https://nuxt.com"><img width="830" height="213" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/banner.svg" alt="Nuxt banner"></a>
+
+# Nuxt
+
+<p>
+  <a href="https://npmx.dev/package/nuxt"><img src="https://npmx.dev/api/registry/badge/version/nuxt" alt="Version"></a>
+  <a href="https://npmx.dev/package/nuxt"><img src="https://npmx.dev/api/registry/badge/downloads/nuxt" alt="Downloads"></a>
+  <a href="https://github.com/nuxt/nuxt/blob/main/LICENSE"><img src="https://img.shields.io/github/license/nuxt/nuxt.svg?style=flat&colorA=18181B&colorB=28CF8D" alt="License"></a>
+  <a href="https://nuxt.com/modules"><img src="https://img.shields.io/badge/dynamic/json?url=https://nuxt.com/api/v1/modules&query=$.stats.modules&label=Modules&style=flat&colorA=18181B&colorB=28CF8D" alt="Modules"></a>
+  <a href="https://nuxt.com"><img src="https://img.shields.io/badge/Nuxt%20Docs-18181B?logo=nuxt" alt="Website"></a>
+  <a href="https://chat.nuxt.dev"><img src="https://img.shields.io/badge/Nuxt%20Discord-18181B?logo=discord" alt="Discord"></a>
+  <a href="https://securityscorecards.dev/viewer/?uri=github.com/nuxt/nuxt"><img src="https://api.securityscorecards.dev/projects/github.com/nuxt/nuxt/badge" alt="Nuxt openssf scorecard score"></a>
+  <a href="https://deepwiki.com/nuxt/nuxt"><img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki"></a>
+</p>
+
+Nuxt is a free and open-source framework with an intuitive and extendable way to create type-safe, performant and production-grade full-stack web applications and websites with Vue.js.
+
+It provides a number of features that make it easy to build fast, SEO-friendly, and scalable web applications, including:
+- Server-side rendering, static site generation, hybrid rendering and edge-side rendering
+- Automatic routing with code-splitting and pre-fetching
+- Data fetching and state management
+- Search engine optimization and defining meta tags
+- Auto imports of components, composables and utils
+- TypeScript with zero configuration
+- Go full-stack with our server/ directory
+- Extensible with [300+ modules](https://nuxt.com/modules)
+- Deployment to a variety of [hosting platforms](https://nuxt.com/deploy)
+- ...[and much more](https://nuxt.com) 🚀
+
+### Table of Contents
+
+- 🚀 [Getting Started](#getting-started)
+- 💻 [Vue Development](#vue-development)
+- 📖 [Documentation](#documentation)
+- 🧩 [Modules](#modules)
+- ❤️ [Contribute](#contribute)
+- 🏠 [Local Development](#local-development)
+- 🛟 [Professional Support](#professional-support)
+- 🔗 [Follow Us](#follow-us)
+- ⚖️ [License](#license)
+
+---
+
+## <a name="getting-started">🚀 Getting Started</a>
+
+Use the following command to create a new starter project. This will create a starter project with all the necessary files and dependencies:
+
+```bash
+npm create nuxt@latest <my-project>
+```
+
+> [!TIP]
+> Discover also [nuxt.new](https://nuxt.new): Open a Nuxt starter on CodeSandbox, StackBlitz or locally to get up and running in a few seconds.
+
+## <a name="vue-development">💻 Vue Development</a>
+
+Simple, intuitive and powerful, Nuxt lets you write Vue components in a way that makes sense. Every repetitive task is automated, so you can focus on writing your full-stack Vue application with confidence.
+
+Example of an `app.vue`:
+
+```vue
+<script setup lang="ts">
+useSeoMeta({
+  title: 'Meet Nuxt',
+  description: 'The Intuitive Vue Framework.',
+})
+</script>
+
+<template>
+  <div id="app">
+    <AppHeader />
+    <NuxtPage />
+    <AppFooter />
+  </div>
+</template>
+
+<style scoped>
+#app {
+  background-color: #020420;
+  color: #00DC82;
+}
+</style>
+```
+
+## <a name="documentation">📖 Documentation</a>
+
+We highly recommend you take a look at the [Nuxt documentation](https://nuxt.com/docs) to level up. It’s a great resource for learning more about the framework. It covers everything from getting started to advanced topics.
+
+## <a name="modules">🧩 Modules</a>
+
+Discover our [list of modules](https://nuxt.com/modules) to supercharge your Nuxt project, created by the Nuxt team and community.
+
+## <a name="contribute">❤️ Contribute</a>
+
+We invite you to contribute and help improve Nuxt 💚
+
+Here are a few ways you can get involved:
+- **Reporting Bugs:** If you come across any bugs or issues, please check out the [reporting bugs guide](https://nuxt.com/docs/4.x/community/reporting-bugs) to learn how to submit a bug report.
+- **Suggestions:** Have ideas to enhance Nuxt? We'd love to hear them! Check out the [contribution guide](https://nuxt.com/docs/4.x/community/contribution) to share your suggestions.
+- **Questions:** If you have questions or need assistance, the [getting help guide](https://nuxt.com/docs/4.x/community/getting-help) provides resources to help you out.
+
+## <a name="local-development">🏠 Local Development</a>
+
+Follow the docs to [Set Up Your Local Development Environment](https://nuxt.com/docs/4.x/community/framework-contribution#setup) to contribute to the framework and documentation.
+
+## <a name="professional-support">🛟 Professional Support</a>
+
+- Technical audit & consulting: [Nuxt Experts](https://nuxt.com/enterprise/support)
+- Custom development & more: [Nuxt Agencies Partners](https://nuxt.com/enterprise/agencies)
+
+## <a name="follow-us">🔗 Follow Us</a>
+
+<p valign="center">
+  <a href="https://go.nuxt.com/discord"><img width="20" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/discord.svg" alt="Discord"></a>&nbsp;&nbsp;<a href="https://go.nuxt.com/x"><img width="20" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/twitter.svg" alt="Twitter"></a>&nbsp;&nbsp;<a href="https://go.nuxt.com/github"><img width="20" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/github.svg" alt="GitHub"></a>&nbsp;&nbsp;<a href="https://go.nuxt.com/bluesky"><img width="20" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/bluesky.svg" alt="Bluesky"></a>
+</p>
+
+## <a name="license">⚖️ License</a>
+
+[MIT](https://github.com/nuxt/nuxt/blob/main/LICENSE)

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+import { Nuxt } from "@nuxt/schema";
+//#region src/index.d.ts
+/**
+ * Experimental server builder implemented with Vite alone.
+ *
+ * It builds the client, emits a document for it, and ships no server of its own: with
+ * `ssr: false` that is a complete static SPA. With SSR enabled the server environment is
+ * built too, but running it is left to a Vite plugin or a custom server.
+ *
+ * Features that need a server are therefore unsupported: server routes and middleware,
+ * route rules, prerendering, and composables that need a request (such as
+ * `useRequestEvent`). Modules work to the extent that they do not require one:
+ * `useNitro()` throws and the `nitro:config` / `nitro:init` hooks never fire.
+ *
+ * TODO: render on the server, by extracting the renderer from `@nuxt/nitro-server` into
+ * something both builders can depend on, and exposing it here as a `{ fetch }` entry
+ * a plugin-provided target can run. Until then the document carries an
+ * `<!--ssr-outlet-->` marker, so a target can supply its own renderer.
+ * TODO: skip building the server environment if unclaimed.
+ */
+declare function bundle(nuxt: Nuxt): Promise<void>;
+//#endregion
+export { bundle };

package/dist/index.mjs

@@ -0,0 +1,339 @@
+import { existsSync } from "node:fs";
+import { dirname, join, relative, resolve } from "pathe";
+import { addTemplate, addVitePlugin, getLayerDirectories, logger, resolvePath } from "@nuxt/kit";
+import { bundlerDiagnostics, setServerBuild } from "@nuxt/kit/internal";
+import { defu } from "defu";
+import { resolveModulePath } from "exsolve";
+import { fileURLToPath } from "node:url";
+import { NodeRequest, sendNodeResponse } from "srvx/node";
+import { serveStatic } from "srvx/static";
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { joinURL, withTrailingSlash } from "ufo";
+import { link } from "clickable-path";
+//#region src/dirs.ts
+let _distDir = dirname(fileURLToPath(import.meta.url));
+if (/(?:chunks|shared)$/.test(_distDir)) _distDir = dirname(_distDir);
+const distDir = _distDir;
+//#endregion
+//#region src/html.ts
+const ESCAPES = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;"
+};
+function escapeAttr(value) {
+	return value.replace(/[&<>"]/g, (c) => ESCAPES[c]);
+}
+function renderAttrs(attrs) {
+	let rendered = "";
+	for (const key in attrs) {
+		const value = attrs[key];
+		if (value === void 0 || value === null || value === false) continue;
+		rendered += value === true ? ` ${key}` : ` ${key}="${escapeAttr(String(value))}"`;
+	}
+	return rendered;
+}
+function renderTag(tag, input) {
+	const { innerHTML, children, textContent, ...attrs } = input;
+	const content = innerHTML ?? children ?? textContent;
+	const open = `<${tag}${renderAttrs(attrs)}>`;
+	return VOID_TAGS.has(tag) ? open : `${open}${content ?? ""}</${tag}>`;
+}
+const VOID_TAGS = /* @__PURE__ */ new Set([
+	"base",
+	"link",
+	"meta"
+]);
+/**
+* Renders the head entries configured in `app.head`. Anything registered at runtime
+* (`useHead`, `definePageMeta`) is applied by unhead once the app mounts, so it is
+* intentionally absent from the static shell.
+*/
+function renderConfiguredHead(nuxt) {
+	const head = nuxt.options.app.head;
+	const tags = [];
+	if (head.title) tags.push(`<title>${escapeAttr(head.title)}</title>`);
+	if (head.base) tags.push(renderTag("base", head.base));
+	for (const meta of head.meta || []) tags.push(renderTag("meta", meta));
+	for (const link of head.link || []) tags.push(renderTag("link", link));
+	for (const style of head.style || []) tags.push(renderTag("style", style));
+	for (const script of head.script || []) tags.push(renderTag("script", script));
+	for (const noscript of head.noscript || []) tags.push(renderTag("noscript", noscript));
+	return tags.join("");
+}
+/**
+* The client reads `window.__NUXT__` for public runtime config and to decide whether
+* it is hydrating server-rendered markup.
+*/
+function renderPayload(nuxt) {
+	const payload = {
+		serverRendered: false,
+		config: {
+			public: nuxt.options.runtimeConfig.public,
+			app: nuxt.options.runtimeConfig.app
+		}
+	};
+	return `<script>window.__NUXT__=${JSON.stringify(payload).replace(/</g, "\\u003C")}<\/script>`;
+}
+/**
+* Renders the SPA document.
+*
+* Only the app entry is linked: stylesheets, module preloads and the transforms of any
+* configured Vite plugin are added by Vite itself, which owns this document as an HTML
+* build input (and, in dev, transforms it on the way out).
+*/
+function renderIndexHtml(nuxt, entry, spaLoadingTemplate = "") {
+	const app = nuxt.options.app;
+	const rootAttrs = renderAttrs(app.rootAttrs);
+	const teleportAttrs = renderAttrs(app.teleportAttrs);
+	const head = renderConfiguredHead(nuxt);
+	const loader = spaLoadingTemplate ? `<${app.spaLoaderTag}${renderAttrs(app.spaLoaderAttrs)}>${spaLoadingTemplate}</${app.spaLoaderTag}>` : "";
+	const root = nuxt.options.ssr === false ? "" : "<!--ssr-outlet-->";
+	const body = [
+		`<${app.rootTag}${rootAttrs}>${root}</${app.rootTag}>`,
+		loader,
+		`<${app.teleportTag}${teleportAttrs}></${app.teleportTag}>`,
+		renderPayload(nuxt),
+		`<script type="module" src="${escapeAttr(entry)}"><\/script>`
+	].join("");
+	return [
+		"<!DOCTYPE html>",
+		`<html${renderAttrs(app.head.htmlAttrs || {})}>`,
+		`<head>${head}</head>`,
+		`<body${renderAttrs(app.head.bodyAttrs || {})}>${body}</body>`,
+		"</html>"
+	].join("");
+}
+//#endregion
+//#region src/templates/spa-loading-icon.ts
+const template = () => {
+	return "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"80\" fill=\"none\" class=\"nuxt-spa-loading\" viewBox=\"0 0 37 25\"><path d=\"M24.236 22.006h10.742L25.563 5.822l-8.979 14.31a4 4 0 0 1-3.388 1.874H2.978l11.631-20 5.897 10.567\"/></svg><style>.nuxt-spa-loading{position:fixed;top:50%;left:50%;transform:translate(-50%,-50%)}.nuxt-spa-loading>path{fill:none;stroke:#00dc82;stroke-width:4px;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:128;stroke-dashoffset:128;animation:nuxt-spa-loading-move 3s linear infinite}@keyframes nuxt-spa-loading-move{to{stroke-dashoffset:-128}}</style>";
+};
+//#endregion
+//#region src/output.ts
+/** Static hosts commonly map unknown paths to one of these files. */
+const SPA_FALLBACK_FILES = [
+	"index.html",
+	"200.html",
+	"404.html"
+];
+async function writeStaticOutput(nuxt, publicDir) {
+	const clientDir = resolve(nuxt.options.buildDir, "dist/client");
+	const document = resolve(clientDir, "index.html");
+	if (!existsSync(document)) throw new Error(`[nuxt:vite-server] Expected \`${document}\` to exist. Did the client build run?`);
+	const html = await readFile(document, "utf-8");
+	await rm(resolve(clientDir, "manifest.json"), { force: true });
+	await mkdir(publicDir, { recursive: true });
+	for (const dirs of getLayerDirectories(nuxt)) if (existsSync(dirs.public)) await cp(dirs.public, publicDir, { recursive: true });
+	await cp(clientDir, publicDir, { recursive: true });
+	for (const file of SPA_FALLBACK_FILES) await writeFile(join(publicDir, file), html, "utf-8");
+	logger.success(`Static SPA output written to ${link(publicDir)}`);
+}
+async function spaLoadingTemplate(nuxt) {
+	if (nuxt.options.spaLoadingTemplate === false) return "";
+	const candidates = typeof nuxt.options.spaLoadingTemplate === "string" ? [resolve(nuxt.options.srcDir, nuxt.options.spaLoadingTemplate)] : nuxt.options._layers.map((layer) => resolve(layer.config.srcDir, layer.config.dir?.app || "app", "spa-loading-template.html"));
+	for (const candidate of candidates) if (existsSync(candidate)) return (await readFile(candidate, "utf-8")).trim();
+	if (nuxt.options.spaLoadingTemplate === true) return template();
+	if (nuxt.options.spaLoadingTemplate) bundlerDiagnostics.NUXT_B7016({ path: nuxt.options.spaLoadingTemplate });
+	return "";
+}
+function publicDirs(nuxt) {
+	return getLayerDirectories(nuxt).map((dirs) => withTrailingSlash(dirs.public)).filter((dir) => existsSync(dir));
+}
+//#endregion
+//#region src/document.ts
+/**
+* Path of the SPA document, at the root of the Vite project so that it is emitted at the
+* root of the client output. A project may put a real file here to take over the
+* document entirely, as it would in any other Vite app; otherwise it is generated.
+*/
+function documentPath(nuxt) {
+	return resolve(nuxt.options.vite.root || nuxt.options.srcDir, "index.html");
+}
+async function resolveDocument(nuxt) {
+	const path = documentPath(nuxt);
+	if (existsSync(path)) return readFile(path, "utf-8");
+	const entry = await resolvePath(resolve(nuxt.options.appDir, nuxt.options.dev || nuxt.options.experimental.asyncEntry ? "entry.async" : "entry"));
+	return renderIndexHtml(nuxt, nuxt.options.dev ? joinURL("/@fs", entry) : "./" + relative(resolve(path, ".."), entry), await spaLoadingTemplate(nuxt));
+}
+/**
+* Provides the generated document as the contents of the HTML build input, so that
+* nothing has to be written into the project to build it.
+*/
+function DocumentPlugin(nuxt) {
+	const path = documentPath(nuxt);
+	return {
+		name: "nuxt:vite-server:document",
+		apply: "build",
+		applyToEnvironment: (environment) => environment.name === "client",
+		resolveId: {
+			order: "pre",
+			filter: { id: new RegExp(`^${escape(path)}$`) },
+			handler: (id) => id
+		},
+		load: {
+			filter: { id: new RegExp(`^${escape(path)}$`) },
+			handler: () => resolveDocument(nuxt)
+		}
+	};
+}
+/**
+* `experimental.entryImportMap` rewrites cross-chunk imports of the entry to the bare
+* `#entry` specifier, so that its hash cannot leak into the chunks importing it. That
+* leaves the document responsible for mapping the specifier to the emitted chunk.
+*/
+function EntryImportMapPlugin() {
+	return {
+		name: "nuxt:vite-server:entry-import-map",
+		apply: "build",
+		applyToEnvironment: (environment) => environment.name === "client",
+		transformIndexHtml: {
+			order: "post",
+			handler(_html, ctx) {
+				for (const chunk of Object.values(ctx.bundle || {})) if (chunk.type === "chunk" && chunk.isEntry && chunk.name === "entry") return [{
+					tag: "script",
+					attrs: { type: "importmap" },
+					children: JSON.stringify({ imports: { "#entry": "./" + chunk.fileName } }),
+					injectTo: "head-prepend"
+				}];
+			}
+		}
+	};
+}
+/**
+* Builds the client environment, and marks the ssr environment as built when nothing
+* will render on the server, so that the orchestrator skips it.
+*
+* A `buildApp` hook rather than a `builder.buildApp` config option, so that a plugin
+* bringing its own deploy target (`@cloudflare/vite-plugin`, for one) keeps its own
+* orchestration and its own environments: those are built as usual.
+*/
+function BuildEnvironmentsPlugin(nuxt) {
+	return {
+		name: "nuxt:vite-server:build-environments",
+		apply: "build",
+		buildApp: {
+			order: "pre",
+			async handler(builder) {
+				const ssr = builder.environments.ssr;
+				if (ssr && nuxt.options.ssr === false) ssr.isBuilt = true;
+				for (const environment of [builder.environments.client, ssr]) if (environment && !environment.isBuilt) await builder.build(environment);
+			}
+		}
+	};
+}
+function escape(path) {
+	return path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/dev.ts
+function setupDevServer(nuxt) {
+	let viteServer;
+	nuxt.hook("vite:serverCreated", (server) => {
+		viteServer = server;
+	});
+	const staticMiddleware = publicDirs(nuxt).map((dir) => serveStatic({ dir }));
+	const shell = async (url) => {
+		const html = await resolveDocument(nuxt);
+		return new Response(viteServer ? await viteServer.transformIndexHtml(url, html) : html, { headers: { "content-type": "text/html;charset=utf-8" } });
+	};
+	nuxt.server = { handler: async (req, res) => {
+		if (viteServer && await handledByVite(viteServer, req, res)) return;
+		const request = new NodeRequest({
+			req,
+			res
+		});
+		const next = (index) => {
+			const middleware = staticMiddleware[index];
+			return middleware ? middleware(request, () => next(index + 1)) : shell(req.url || "/");
+		};
+		await sendNodeResponse(res, await next(0));
+	} };
+}
+function handledByVite(server, req, res) {
+	return new Promise((resolvePromise, reject) => {
+		const originalUrl = req.url;
+		server.middlewares.handle(req, res, (error) => {
+			req.url = originalUrl;
+			if (error) return reject(error);
+			resolvePromise(false);
+		});
+		res.on("close", () => resolvePromise(true));
+	}).then((handled) => handled || res.writableEnded);
+}
+//#endregion
+//#region src/index.ts
+/**
+* Experimental server builder implemented with Vite alone.
+*
+* It builds the client, emits a document for it, and ships no server of its own: with
+* `ssr: false` that is a complete static SPA. With SSR enabled the server environment is
+* built too, but running it is left to a Vite plugin or a custom server.
+*
+* Features that need a server are therefore unsupported: server routes and middleware,
+* route rules, prerendering, and composables that need a request (such as
+* `useRequestEvent`). Modules work to the extent that they do not require one:
+* `useNitro()` throws and the `nitro:config` / `nitro:init` hooks never fire.
+*
+* TODO: render on the server, by extracting the renderer from `@nuxt/nitro-server` into
+* something both builders can depend on, and exposing it here as a `{ fetch }` entry
+* a plugin-provided target can run. Until then the document carries an
+* `<!--ssr-outlet-->` marker, so a target can supply its own renderer.
+* TODO: skip building the server environment if unclaimed.
+*/
+function bundle(nuxt) {
+	if (nuxt.options.builder !== "@nuxt/vite-builder") throw new Error("`@nuxt/vite-server` requires the Vite builder.");
+	logger.warn("`@nuxt/vite-server` is experimental. It builds with Vite alone and ships no server, so features and modules that need one will not work.");
+	if (nuxt.options.ssr !== false) logger.warn("`@nuxt/vite-server` does not render on the server. The server environment is built for a vite plugin or a custom server to run; until one does, the document is served as a client-only shell.");
+	warnUnsupported(nuxt);
+	const outputDir = resolve(nuxt.options.rootDir, nuxt.options.nitro.output?.dir || ".output");
+	const publicDir = resolve(outputDir, "public");
+	setServerBuild({
+		name: "vite",
+		label: "Vite SPA",
+		output: {
+			dir: () => outputDir,
+			publicDir: () => publicDir
+		},
+		capabilities: {
+			server: nuxt.options.ssr !== false,
+			dev: true
+		},
+		buildsSeparately: false,
+		runtime: {
+			fetch: resolve(distDir, "runtime/fetch"),
+			runtimeConfig: resolve(nuxt.options.buildDir, "vite-server/runtime-config.mjs")
+		},
+		preview: { staticDir: () => publicDir }
+	}, nuxt);
+	addTemplate({
+		filename: "vite-server/runtime-config.mjs",
+		write: true,
+		getContents: ({ nuxt }) => [`const config = ${JSON.stringify({
+			app: nuxt.options.runtimeConfig.app,
+			public: nuxt.options.runtimeConfig.public
+		})}`, `export const useRuntimeConfig = () => globalThis.__NUXT__?.config || config`].join("\n")
+	});
+	nuxt.options.experimental.appManifest = false;
+	nuxt.options.alias["#app-manifest"] = resolveModulePath("mocked-exports/empty", { from: import.meta.url });
+	nuxt.options.vite.plugins ||= [];
+	nuxt.options.vite.plugins.push(BuildEnvironmentsPlugin(nuxt));
+	if (!nuxt.options.dev) {
+		nuxt.options.vite.$client = defu(nuxt.options.vite.$client, { build: { rolldownOptions: { input: { index: documentPath(nuxt) } } } });
+		addVitePlugin(() => [DocumentPlugin(nuxt), EntryImportMapPlugin()], { server: false });
+	}
+	if (nuxt.options.dev) setupDevServer(nuxt);
+	else nuxt.hook("build:done", () => writeStaticOutput(nuxt, publicDir));
+	return Promise.resolve();
+}
+function warnUnsupported(nuxt) {
+	const unsupported = [];
+	if (nuxt.options.serverHandlers.length || getLayerDirectories(nuxt).some((dirs) => existsSync(dirs.server))) unsupported.push("server routes and server middleware");
+	if (Object.keys(nuxt.options.routeRules || {}).length || Object.keys(nuxt.options.nitro.routeRules || {}).length) unsupported.push("route rules");
+	if (nuxt.options.nitro.prerender?.routes?.length || nuxt.options.nitro.prerender?.crawlLinks) unsupported.push("prerendering");
+	if (nuxt.options.dev && nuxt.options.devServerHandlers.length) unsupported.push("dev server handlers");
+	if (unsupported.length) logger.warn(`\`@nuxt/vite-server\` builds a static SPA with no server, so ${unsupported.join(", ")} will be ignored.`);
+}
+//#endregion
+export { bundle };

package/dist/runtime/fetch.mjs

@@ -0,0 +1,4 @@
+//#region src/runtime/fetch.ts
+const fetch = (...args) => globalThis.fetch(...args);
+//#endregion
+export { fetch };

package/package.json

@@ -1,8 +1,49 @@
 {
   "name": "@nuxt/vite-server-nightly",
-  "version": "0.0.0",
+  "version": "5.0.0-29802883.a46ecec7",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuxt/nuxt.git",
+    "directory": "packages/vite-server"
+  },
+  "description": "Experimental pure Vite server builder for Nuxt",
+  "homepage": "https://nuxt.com",
+  "license": "MIT",
+  "type": "module",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist"
   ],
-  "author": "Daniel Roe <daniel@roe.dev>"
-}
+  "dependencies": {
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@5.0.0-29802883.a46ecec7",
+    "clickable-path": "^0.1.0",
+    "defu": "^6.1.7",
+    "exsolve": "^1.1.1",
+    "mocked-exports": "^0.1.1",
+    "pathe": "^2.0.3",
+    "srvx": "0.11.22",
+    "ufo": "^1.6.4"
+  },
+  "devDependencies": {
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@5.0.0-29802883.a46ecec7",
+    "tsdown": "0.22.14",
+    "vite": "^8.2.2",
+    "vitest": "4.1.11"
+  },
+  "peerDependencies": {
+    "nuxt": "npm:nuxt-nightly@5.0.0-29802883.a46ecec7",
+    "vite": "^8.2.2"
+  },
+  "engines": {
+    "node": "^22.19.0 || ^24.11.0 || >=26.0.0"
+  },
+  "_name": "@nuxt/vite-server",
+  "scripts": {
+    "build": "tsdown",
+    "test:attw": "node ../../scripts/test-attw.ts"
+  }
+}