@nuxt/vite-server-nightly 0.0.0 → 4.5.2-2610052030-052d82e

package/dist/runtime/dev-error.mjs

@@ -0,0 +1,92 @@
+import process from "node:process";
+import { ERROR_CHANNEL_ENV, clearErrorReport, createDevErrorReporter, createErrorReport, serializeErrorCause, setErrorChannelForwarding, useErrorChannel } from "nuxt/internal/dev-error";
+import { isLoopbackAddress } from "nuxt/internal/dev/peer";
+//#region src/runtime/dev-error.ts
+let context;
+/** Whether a dev server in front owns the channel. */
+const forwarding = () => !!process.env[ERROR_CHANNEL_ENV];
+setErrorChannelForwarding(forwarding);
+/** Install the dev server the app renders from. */
+function setDevErrorContext(next) {
+	context = next;
+	useErrorChannel().catch(() => {});
+}
+/** Whether `pathname` is a live channel route this process serves. */
+function isErrorChannelRequest(pathname) {
+	if (!context || forwarding()) return false;
+	const base = context.channel.replace(/\/$/, "");
+	return pathname === base || pathname.startsWith(`${base}/`);
+}
+/**
+* Serve the live error channel: the SSE stream, report lookups and "open in editor".
+*
+* Trust follows the socket, since a request's origin headers are forgeable over a direct
+* connection.
+*/
+async function fetchErrorChannel(request) {
+	return await (await useErrorChannel()).fetchHandler(request, { trusted: isLoopbackAddress(request.ip) }) ?? new Response("Not Found", { status: 404 });
+}
+/**
+* Build a report from the stack as raised, publish it, then rewrite the stack in place so
+* every later consumer sees source positions.
+*/
+function observeDevError(error, request, observe) {
+	if (!context) return Promise.resolve(void 0);
+	return reporter(error, request, observe);
+}
+const reporter = createDevErrorReporter({
+	get cwd() {
+		return context.cwd;
+	},
+	channel: channelPath,
+	createReport: (error) => buildReport(error),
+	requestInfo: (request) => ({
+		method: request.method,
+		url: new URL(request.url),
+		headers: request.headers
+	}),
+	mapStack: (error) => fixStacktraces(error, context.server)
+});
+async function buildReport(error) {
+	const { viteLoader } = await import("my-bad/vite");
+	return createErrorReport(error, {
+		cwd: context.cwd,
+		loaders: [viteLoader(ssrOnly(context.server), { fs: false })]
+	});
+}
+/**
+* The dev server with only its SSR environment visible, since `viteLoader` maps through
+* the first environment holding the file and an SSR frame belongs to the SSR transform.
+*/
+function ssrOnly(server) {
+	return Object.create(server, { environments: { value: { ssr: server.environments.ssr } } });
+}
+/**
+* Ask Vite to map the stacks of an error and its causes. It maps in place and appends to
+* `message` on a stack it has already rewritten, so each one is mapped on a carrier.
+*/
+function fixStacktraces(error, server, seen = /* @__PURE__ */ new Set()) {
+	if (!(error instanceof Error) || seen.has(error)) return;
+	seen.add(error);
+	if (typeof error.stack === "string") {
+		const carrier = { stack: error.stack };
+		server.ssrFixStacktrace(carrier);
+		if (carrier.stack) try {
+			Object.defineProperty(error, "stack", {
+				value: carrier.stack,
+				writable: true,
+				configurable: true
+			});
+		} catch {}
+	}
+	fixStacktraces(error.cause, server, seen);
+}
+/** The error's `cause` chain, as the error page receives it in the payload. */
+function errorCause(error) {
+	return serializeErrorCause(error?.cause);
+}
+function channelPath() {
+	return process.env[ERROR_CHANNEL_ENV] || context.channel;
+}
+//#endregion
+export { clearErrorReport, errorCause, fetchErrorChannel, isErrorChannelRequest, observeDevError, setDevErrorContext };

package/dist/runtime/dev-handler.mjs

@@ -0,0 +1,9 @@
+//#region src/runtime/dev-handler.ts
+/** Stands in for the render in development, where the dev server serves the app. */
+const fetch = () => Promise.resolve(new Response("The Nuxt server handler is only emitted by a build. In development the app is served by the Nuxt dev server.", {
+	status: 503,
+	headers: { "content-type": "text/plain;charset=utf-8" }
+}));
+var dev_handler_default = { fetch };
+//#endregion
+export { dev_handler_default as default, fetch };

package/dist/runtime/event.mjs

@@ -0,0 +1,16 @@
+//#region src/runtime/event.ts
+/**
+* The request event the renderer reads, described in web standards only: a platform
+* `Request`, its URL, a mutable response to influence, and a context the app layer stores
+* per-request state in.
+*/
+function createRequestEvent(request) {
+	return {
+		req: request,
+		url: new URL(request.url),
+		res: { headers: new Headers() },
+		context: {}
+	};
+}
+//#endregion
+export { createRequestEvent };

package/dist/runtime/node.mjs

@@ -0,0 +1,51 @@
+import { fileURLToPath } from "node:url";
+import { readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { serve } from "srvx/node";
+import { staticMiddleware } from "srvx/static";
+//#region src/runtime/node.ts
+/**
+* Serve the build's static assets, and hand everything else to the renderer.
+*
+* The static handler comes first so a request for a hashed asset never reaches a render.
+*/
+function createNodeServer(options) {
+	const dir = typeof options.publicDir === "string" ? options.publicDir : fileURLToPath(options.publicDir);
+	const serveStatic = staticMiddleware({ dir });
+	const publicFiles = listFiles(dir);
+	return { fetch: async (request) => {
+		const files = await publicFiles;
+		if (!files || mayBeStaticFile(files, request)) return serveStatic(request, () => options.fetch(request));
+		return options.fetch(request);
+	} };
+}
+async function listFiles(dir) {
+	try {
+		const entries = await readdir(dir, {
+			recursive: true,
+			withFileTypes: true
+		});
+		const files = /* @__PURE__ */ new Set();
+		for (const entry of entries) if (entry.isFile()) files.add("/" + relative(dir, join(entry.parentPath, entry.name)).split(sep).join("/"));
+		return files;
+	} catch {
+		return;
+	}
+}
+/** Whether the request path, or one of the variants the static handler tries, is a public file. */
+function mayBeStaticFile(files, request) {
+	let path;
+	try {
+		path = decodeURIComponent(new URL(request.url).pathname);
+	} catch {
+		return true;
+	}
+	if (path.endsWith("/")) return files.has(path + "index.html");
+	return files.has(path) || files.has(path + ".html") || files.has(path + "/index.html");
+}
+/** Listen for requests, using the port and host the platform environment configures. */
+function listen(server) {
+	serve({ fetch: server.fetch });
+}
+//#endregion
+export { createNodeServer, listen };

package/dist/runtime/prerender.mjs

@@ -0,0 +1,58 @@
+import { NuxtServerError } from "./renderer.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/runtime/prerender.ts
+/**
+* The capabilities the renderer only has while prerendering. Everything is held in memory:
+* the crawler drives the handler in-process, so nothing outlives the build.
+*/
+function createPrerenderOptions(options = {}) {
+	const payloads = /* @__PURE__ */ new Map();
+	return {
+		payloadCache: {
+			hasItem: (key) => payloads.has(key),
+			getItem: (key) => payloads.get(key),
+			setItem: (key, value) => void payloads.set(key, value)
+		},
+		sharedDataCache: options.sharedData === false ? void 0 : createSharedDataCache(),
+		wrapRender: (event, render) => {
+			const renderingURL = event.url.pathname + event.url.search;
+			const stack = renderingURLs.getStore();
+			if (stack?.includes(renderingURL)) {
+				const chain = [...stack, renderingURL].filter((url) => !url.startsWith("/__nuxt_error")).map((url) => `"${url}"`).join(" -> ");
+				throw new NuxtServerError({
+					status: 508,
+					statusText: `Loop detected while prerendering "${renderingURL}" (${chain}). Check for \`useFetch\`/\`$fetch\` calls targeting a URL that is currently being rendered.`
+				});
+			}
+			return renderingURLs.run([...stack || [], renderingURL], render);
+		}
+	};
+}
+/** URLs rendering in the active async context, oldest first. A repeat entry is a cycle. */
+const renderingURLs = new AsyncLocalStorage();
+function createSharedDataCache() {
+	const resolved = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const chains = /* @__PURE__ */ new Map();
+	return {
+		get(key) {
+			const chain = renderingURLs.getStore();
+			const setChain = chains.get(key);
+			if (chain?.length && setChain?.length && setChain.some((url) => chain.includes(url))) return;
+			return pending.get(key) ?? resolved.get(key);
+		},
+		async set(key, value) {
+			pending.set(key, value);
+			const chain = renderingURLs.getStore();
+			if (chain?.length) chains.set(key, chain);
+			try {
+				resolved.set(key, Promise.resolve(await value));
+			} catch {} finally {
+				pending.delete(key);
+				chains.delete(key);
+			}
+		}
+	};
+}
+//#endregion
+export { createPrerenderOptions };

package/dist/runtime/renderer.mjs

@@ -0,0 +1,220 @@
+import { createRequestEvent } from "./event.mjs";
+import { joinURL, withQuery } from "ufo";
+import { appendVary, describeError, isExpectedError, isJsonRequest } from "nuxt/internal/renderer/error";
+import { mergeHeaders } from "nuxt/internal/renderer/headers";
+import { useServerHooks } from "nuxt/server";
+import { buildAssetsURL, publicAssetsURL } from "#internal/nuxt/paths";
+//#region src/runtime/renderer.ts
+/** An error carrying the HTTP status the renderer refused a request with. */
+var NuxtServerError = class extends Error {
+	status;
+	statusText;
+	data;
+	headers;
+	constructor(init) {
+		super(init.statusText || `Request failed with status ${init.status}`);
+		this.name = "NuxtServerError";
+		this.status = init.status;
+		this.statusText = init.statusText || "";
+		this.data = init.data;
+		this.headers = init.headers;
+	}
+};
+/**
+* The capabilities `@nuxt/vite-server` provides to the renderer. Everything comes from the
+* platform or from values the build serialised, so the same options run on a node server
+* and in a web-standard worker.
+*
+* Route rules come from the matcher the build compiled, so a route is server-rendered
+* unless a rule says otherwise.
+*/
+function createRendererOptions(runtimeConfig, matchRouteRules, prerender) {
+	globalThis.__buildAssetsURL = buildAssetsURL;
+	globalThis.__publicAssetsURL = publicAssetsURL;
+	return {
+		runtimeConfig,
+		buildAssetsURL,
+		publicAssetsURL,
+		getRouteRules: (event) => ({
+			ssr: true,
+			...matchRouteRules(event.url.pathname)
+		}),
+		hooks: useServerHooks,
+		createResponse: (body, init) => new Response(body, init),
+		createError: (init) => new NuxtServerError(init),
+		prerender,
+		onRenderSuccess: import.meta.dev ? () => {
+			import("./dev-error.mjs").then(({ clearErrorReport }) => clearErrorReport()).catch(() => {});
+		} : void 0,
+		captureError: (error) => {
+			if (!import.meta.dev) console.error(error);
+		},
+		onDevError: import.meta.dev ? (error, event, options) => import("./dev-error.mjs").then(({ observeDevError }) => observeDevError(error, event.req, options)) : void 0
+	};
+}
+/**
+* Header the crawler reads additional routes from. The renderer collects them on the
+* request event, which does not cross the handler boundary, so they ride the response.
+*/
+const PRERENDER_HINTS_HEADER = "x-nuxt-prerender";
+/**
+* A web-standard handler over the renderer: it renders the request, and renders the app's
+* error page for a request the render refused. In development it also serves the live
+* error channel and publishes what it failed on to it.
+*/
+function createFetchHandler(renderer, matchRouteRules) {
+	return async function fetch(request) {
+		if (import.meta.dev) {
+			const devErrors = await import("./dev-error.mjs");
+			if (devErrors.isErrorChannelRequest(new URL(request.url).pathname)) return devErrors.fetchErrorChannel(request);
+		}
+		const event = createRequestEvent(request);
+		const rules = matchRouteRules(event.url.pathname);
+		if (rules.redirect) return redirectResponse(event, rules.redirect, rules.headers);
+		try {
+			const response = await renderer.fetch(event);
+			applyHeaders(response, rules.headers);
+			if (import.meta.prerender) applyPrerenderHints(event, response);
+			return response;
+		} catch (error) {
+			const response = await renderError(renderer, request, error, event);
+			applyHeaders(response, rules.headers);
+			if (import.meta.prerender) applyPrerenderHints(event, response);
+			return response;
+		}
+	};
+}
+function applyHeaders(response, headers) {
+	for (const name in headers) response.headers.set(name, headers[name]);
+}
+/**
+* Answer a `redirect` rule. A target carrying `**` moves a whole subtree: the tail of the
+* request past the prefix the rule matched under is interpolated into it. Targets naming a
+* parameter of the matched pattern are not resolved; those need a server runtime.
+*/
+function redirectResponse(event, redirect, headers) {
+	let location = redirect.to;
+	if (location.includes("**")) {
+		const path = event.url.pathname;
+		const tail = redirect.base && path.startsWith(redirect.base) ? path.slice(redirect.base.length) : path;
+		location = location.endsWith("/**") ? joinURL(location.slice(0, -3), tail) : location.replace("**", tail.replace(/^\//, ""));
+	}
+	const target = appendSearch(location, event.url.search);
+	const response = new Response(redirectBody(target), {
+		status: redirect.status ?? 307,
+		headers: {
+			"location": target,
+			"content-type": "text/html"
+		}
+	});
+	applyHeaders(response, headers);
+	return response;
+}
+/** A meta-refresh document, so a prerendered redirect is followed when served as a static file. */
+function redirectBody(location) {
+	return `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${location.replace(REDIRECT_UNSAFE_RE, (char) => REDIRECT_ESCAPES[char])}"></head></html>`;
+}
+const REDIRECT_ESCAPES = {
+	"\"": "%22",
+	"'": "%27",
+	"<": "%3C",
+	">": "%3E",
+	"&": "%26"
+};
+const REDIRECT_UNSAFE_RE = /["'<>&]/g;
+/** Carry the request's query onto a redirect target, ahead of any fragment the target names. */
+function appendSearch(target, search) {
+	if (!search) return target;
+	const hashIndex = target.indexOf("#");
+	const path = hashIndex === -1 ? target : target.slice(0, hashIndex);
+	const hash = hashIndex === -1 ? "" : target.slice(hashIndex);
+	return path + (!path.includes("?") ? "?" : path.endsWith("?") || path.endsWith("&") ? "" : "&") + search.slice(1) + hash;
+}
+function applyPrerenderHints(event, response) {
+	const paths = event.context.nuxt?.prerenderRoutes;
+	if (!paths?.length) return;
+	response.headers.append(PRERENDER_HINTS_HEADER, paths.map((path) => encodeURIComponent(path)).join(", "));
+}
+async function renderError(renderer, request, error, event) {
+	const described = describeError(error);
+	const { status, statusText, message } = described;
+	const url = new URL(request.url);
+	const devErrors = import.meta.dev ? await import("./dev-error.mjs") : void 0;
+	const report = devErrors ? await devErrors.observeDevError(error, request, { expected: isExpectedError(error, described) }).catch(() => void 0) : void 0;
+	if (isJsonRequest(request, url.pathname)) {
+		const body = {
+			error: true,
+			status,
+			statusText,
+			message,
+			data: described.data,
+			...import.meta.dev && { stack: error?.stack?.split("\n").map((line) => line.trim()) }
+		};
+		return new Response(JSON.stringify(body), {
+			status,
+			statusText,
+			headers: errorResponseHeaders(event, described, "application/json;charset=utf-8")
+		});
+	}
+	const data = error?.data;
+	const stack = error?.stack;
+	const errorEvent = createRequestEvent(new Request(withQuery(new URL("/__nuxt_error", url).href, {
+		status: String(status),
+		statusCode: String(status),
+		statusText,
+		statusMessage: statusText,
+		message,
+		url: request.url,
+		...data === void 0 ? {} : { data: typeof data === "string" ? data : JSON.stringify(data) },
+		...import.meta.dev && stack ? { stack } : {}
+	}), { headers: request.headers }));
+	const state = (import.meta.prerender ? event.context.nuxt : void 0) || {};
+	state["~rendering-error"] = true;
+	if (devErrors) {
+		const cause = devErrors.errorCause(error);
+		if (cause !== void 0) state["~error-cause"] = cause;
+	}
+	errorEvent.context.nuxt = state;
+	if (import.meta.prerender) event.context.nuxt = state;
+	const rendered = await renderer.fetch(errorEvent).catch(() => null);
+	if (rendered) {
+		const responseHeaders = errorResponseHeaders(event, described, "text/html;charset=utf-8", rendered.headers);
+		if (report && !import.meta.test) {
+			const html = await rendered.text();
+			const body = await report.overlay(html).catch(() => html);
+			return new Response(body, {
+				status,
+				statusText,
+				headers: responseHeaders
+			});
+		}
+		return new Response(rendered.body, {
+			status,
+			statusText,
+			headers: responseHeaders
+		});
+	}
+	if (report) {
+		const page = await report.page().catch(() => void 0);
+		if (page) return new Response(page, {
+			status,
+			statusText,
+			headers: errorResponseHeaders(event, described, "text/html;charset=utf-8")
+		});
+	}
+	return new Response(message, {
+		status,
+		statusText,
+		headers: errorResponseHeaders(event, described, "text/plain;charset=utf-8")
+	});
+}
+function errorResponseHeaders(event, described, contentType, page) {
+	const headers = new Headers(event.res.headers);
+	if (page) mergeHeaders(headers, page);
+	mergeHeaders(headers, described.headers);
+	headers.set("content-type", contentType);
+	appendVary(headers, "accept, sec-fetch-mode");
+	return headers;
+}
+//#endregion
+export { NuxtServerError, createFetchHandler, createRendererOptions };

package/dist/runtime/server.mjs

@@ -0,0 +1,15 @@
+import { joinURL } from "ufo";
+import { resolveServerFetchInit } from "nuxt/internal/server-default";
+//#region src/runtime/server.ts
+/** The `nuxt/server` helpers backed by the build's route rules and app handler. */
+function createServerHelpers(match, loadFetch, baseURL) {
+	return {
+		getRouteRules: (event) => match(event.url.pathname),
+		matchRouteRules: (path, _method) => match(joinURL(baseURL, path)),
+		serverFetch: async (event, path, init) => {
+			return (await loadFetch())(new Request(new URL(joinURL(baseURL, path), event.req.url), resolveServerFetchInit(event, init)));
+		}
+	};
+}
+//#endregion
+export { createServerHelpers };

package/package.json

@@ -1,8 +1,52 @@
 {
   "name": "@nuxt/vite-server-nightly",
-  "version": "0.0.0",
+  "version": "4.5.2-2610052030-052d82e",
+  "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@4.5.2-2610052030-052d82e",
+    "clickable-path": "^0.1.1",
+    "defu": "^6.1.7",
+    "exsolve": "^1.1.3",
+    "mocked-exports": "^0.1.1",
+    "my-bad": "^0.2.10",
+    "pathe": "^2.0.3",
+    "rou3": "^0.9.2",
+    "srvx": "1.0.5",
+    "ufo": "^1.6.4",
+    "ultrahtml": "^1.7.0"
+  },
+  "devDependencies": {
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.5.2-2610052030-052d82e",
+    "nuxt": "npm:nuxt-nightly@4.5.2-2610052030-052d82e",
+    "tsdown": "0.23.0",
+    "vite": "^8.3.1",
+    "vitest": "5.0.3"
+  },
+  "peerDependencies": {
+    "nuxt": "npm:nuxt-nightly@4.5.2-2610052030-052d82e",
+    "vite": "^8.3.1"
+  },
+  "engines": {
+    "node": "^22.22.3 || ^24.15.0 || >=26.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test:attw": "node ../../scripts/test-attw.ts"
+  }
+}