nitro-nightly 3.0.1-20251023-220447-2d199369 → 3.1.0-20251024-111905-4718bf73

package/dist/_chunks/build.mjs

@@ -66,6 +66,7 @@ import 'rendu';
 import 'vite';
 import 'get-port-please';
 import 'node:child_process';
+import 'node:assert/strict';
 
 async function viteBuild(nitro$1) {
   if (nitro$1.options.dev) {

package/dist/_chunks/build3.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import defu$1, { defu } from 'defu';
-import { E as Builder, M as MagicString, s as sanitizeFilePath, a as scanHandlers, f as formatCompatibilityDate } from './index.mjs';
+import { F as Builder, M as MagicString, s as sanitizeFilePath, a as scanHandlers, f as formatCompatibilityDate } from './index.mjs';
 import { runtimeDir } from 'nitro/runtime/meta';
 import { a as alias, i as inject } from './index2.mjs';
 import sysPath__default, { resolve as resolve$2, relative, join, dirname, extname, basename, sep, normalize } from 'path';

package/dist/_chunks/index.mjs

@@ -22268,4 +22268,4 @@ function genRawValue(value, indent = "", options = {}) {
   return value.toString();
 }
 
-export { loadOptions as A, runTask as B, C, listTasks as D, Builder as E, pm$1 as F, decode as G, encode as H, createUnimport as I, genSafeVariableName as J, genImport as K, genString as L, MagicString as M, N$1 as N, genObjectFromRaw as O, Parser as P, findNearestFile as Q, readGitConfig as R, readPackageJSON as S, findFile as T, fileURLToPath as U, resolveCompatibilityDatesFromEnv as V, index as W, scanHandlers as a, glob as b, snapshotStorage as c, copyPublicAssets as d, prettyPath as e, formatCompatibilityDate as f, getMagicString as g, h, createNitro as i, prepare as j, addRoute as k, scanUnprefixedPublicAssets as l, mime as m, compressPublicAssets as n, findAllRoutes as o, parse$1 as p, createRouter as q, resolveModulePath as r, sanitizeFilePath as s, genObjectKey as t, resolveNitroPath as u, toExports as v, writeFile as w, parseNodeModulePath as x, lookupNodeModuleSubpath as y, isDirectory as z };
+export { isDirectory as A, loadOptions as B, C, runTask as D, listTasks as E, Builder as F, pm$1 as G, decode as H, encode as I, createUnimport as J, genSafeVariableName as K, genImport as L, MagicString as M, N$1 as N, genString as O, Parser as P, genObjectFromRaw as Q, findNearestFile as R, readGitConfig as S, readPackageJSON as T, findFile as U, fileURLToPath as V, resolveCompatibilityDatesFromEnv as W, index as X, scanHandlers as a, glob as b, snapshotStorage as c, copyPublicAssets as d, prettyPath as e, formatCompatibilityDate as f, getMagicString as g, h, stripLiteral as i, prepare as j, createNitro as k, addRoute as l, mime as m, scanUnprefixedPublicAssets as n, compressPublicAssets as o, parse$1 as p, findAllRoutes as q, resolveModulePath as r, sanitizeFilePath as s, createRouter as t, genObjectKey as u, resolveNitroPath as v, writeFile as w, toExports as x, parseNodeModulePath as y, lookupNodeModuleSubpath as z };

package/dist/_chunks/index3.mjs

@@ -1,4 +1,4 @@
-import { i as createNitro, k as addRoute, l as scanUnprefixedPublicAssets, n as compressPublicAssets, m as mime, w as writeFile, o as findAllRoutes, q as createRouter, t as genObjectKey, u as resolveNitroPath, v as toExports, r as resolveModulePath, x as parseNodeModulePath, y as lookupNodeModuleSubpath, z as isDirectory } from './index.mjs';
+import { k as createNitro, l as addRoute, n as scanUnprefixedPublicAssets, o as compressPublicAssets, m as mime, w as writeFile, q as findAllRoutes, t as createRouter, u as genObjectKey, v as resolveNitroPath, x as toExports, r as resolveModulePath, y as parseNodeModulePath, z as lookupNodeModuleSubpath, A as isDirectory } from './index.mjs';
 import { pathToFileURL } from 'node:url';
 import { colors } from 'consola/utils';
 import { defu } from 'defu';

package/dist/_chunks/info.mjs

@@ -1,4 +1,4 @@
-import { F as pm, M as MagicString, P as Parser, G as decode, H as encode, I as createUnimport, J as genSafeVariableName, K as genImport, L as genString, O as genObjectFromRaw, b as glob, m as mime, r as resolveModulePath, w as writeFile } from './index.mjs';
+import { G as pm, M as MagicString, P as Parser, H as decode, I as encode, J as createUnimport, K as genSafeVariableName, L as genImport, O as genString, Q as genObjectFromRaw, b as glob, m as mime, r as resolveModulePath, w as writeFile } from './index.mjs';
 import sysPath__default, { win32, posix, isAbsolute, resolve as resolve$1 } from 'path';
 import { defineEnv } from 'unenv';
 import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
@@ -9892,7 +9892,7 @@ async function getWasmImports(asset, _opts) {
       resolved: true
     };
   }
-  const { readPackageJSON } = await import('./index.mjs').then(function (n) { return n.W; });
+  const { readPackageJSON } = await import('./index.mjs').then(function (n) { return n.X; });
   const pkgJSON = await readPackageJSON(asset.id);
   let resolved = true;
   const imports = [];

package/dist/_chunks/plugin.mjs

@@ -1,9 +1,9 @@
-import { s as sanitizeFilePath, f as formatCompatibilityDate, d as copyPublicAssets, a as scanHandlers, r as resolveModulePath, e as prettyPath, i as createNitro, j as prepare } from './index.mjs';
+import { 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 { existsSync, watch as watch$1 } from 'node:fs';
+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';
@@ -25,14 +25,17 @@ import 'jiti';
 import 'klona';
 import 'unstorage';
 import 'ohash';
-import { resolve as resolve$1, join as join$1 } from 'node:path';
+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 } from 'vite';
+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;
@@ -221,6 +224,7 @@ async function buildEnvironments(ctx, builder) {
       nitroOptions.renderer.template = tmp;
     }
   }
+  await builder.writeAssetsManifest?.();
   if (!isTest && !isCI) console.log();
   const buildInfo = [
     ["preset", nitro.options.preset],
@@ -635,234 +639,749 @@ function nitroPreviewPlugin(ctx) {
   };
 }
 
+//#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 "@hiogawa/vite-plugin-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
+					};
+				}
+			} },
+			load: { async handler(id) {
+				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 this.resolve("./runtime.js", import.meta.filename);
+				}
+			},
+			load: { async handler(id) {
+				if (id === "\0virtual:fullstack/empty-assets") return `export default ${JSON.stringify(EMPTY_ASSETS)}`;
+				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;
+				}
+			}
+		}
+	};
+}
+
 const DEFAULT_EXTENSIONS = [".ts", ".js", ".mts", ".mjs", ".tsx", ".jsx"];
+const debug = process.env.NITRO_DEBUG ? (...args) => console.log("[nitro]", ...args) : () => {
+};
 function nitro(pluginConfig = {}) {
-  const ctx = {
-    pluginConfig,
-    _entryPoints: {},
-    _manifest: {},
-    _serviceBundles: {}
-  };
+  const ctx = createContext(pluginConfig);
   return [
-    nitroPlugin(ctx),
-    nitroServicePlugin(ctx),
+    nitroInit(ctx),
+    nitroEnv(ctx),
+    nitroMain(ctx),
+    nitroPrepare(ctx),
+    nitroService(ctx),
     nitroPreviewPlugin(),
-    nitroRollupPlugins(ctx)
+    pluginConfig.experimental?.assetsImport !== false && assetsPlugin({
+      experimental: {
+        // See https://github.com/hi-ogawa/vite-plugins/pull/1289
+        clientBuildFallback: false
+      }
+    })
   ];
 }
-function nitroPlugin(ctx) {
-  return [
-    {
-      name: "nitro:main",
-      // Opt-in this plugin into the shared plugins pipeline
-      sharedDuringBuild: true,
-      // Only apply this plugin during build or dev
-      apply: (config, configEnv) => !configEnv.isPreview,
-      // Extend vite config before it's resolved
-      async config(userConfig, configEnv) {
-        ctx.nitro = ctx.pluginConfig._nitro || await createNitro({
-          dev: configEnv.mode === "development",
-          rootDir: userConfig.root,
-          ...defu(ctx.pluginConfig.config, userConfig.nitro)
-        });
-        if (!ctx.pluginConfig.services?.ssr) {
-          ctx.pluginConfig.services ??= {};
-          if (userConfig.environments?.ssr === void 0) {
-            const ssrEntry = resolveModulePath("./entry-server", {
-              from: ["", "app", "src"].flatMap(
-                (d) => ctx.nitro.options.scanDirs.map((s) => join(s, d) + "/")
-              ),
-              extensions: DEFAULT_EXTENSIONS,
-              try: true
-            });
-            if (ssrEntry) {
-              ctx.pluginConfig.services.ssr = { entry: ssrEntry };
-              ctx.nitro.logger.info(
-                `Using \`${prettyPath(ssrEntry)}\` as vite ssr entry.`
-              );
-            }
-          } else {
-            let ssrEntry = getEntry(
-              userConfig.environments.ssr.build?.rollupOptions?.input
-            );
-            if (typeof ssrEntry === "string") {
-              ssrEntry = resolveModulePath(ssrEntry, {
-                from: ctx.nitro.options.scanDirs,
-                extensions: DEFAULT_EXTENSIONS,
-                suffixes: ["", "/index"],
-                try: true
-              }) || ssrEntry;
-              ctx.pluginConfig.services.ssr = { entry: ssrEntry };
-            } else {
-              this.error(`Invalid input type for SSR entry point.`);
-            }
+function nitroInit(ctx) {
+  return {
+    name: "nitro:init",
+    sharedDuringBuild: true,
+    apply: (_config, configEnv) => !configEnv.isPreview,
+    async config(config, configEnv) {
+      if (!ctx._initialized) {
+        debug("[init] Initializing nitro");
+        ctx._initialized = true;
+        await setupNitroContext(ctx, configEnv, config);
+      }
+    },
+    applyToEnvironment(env) {
+      if (env.name === "nitro" && ctx.nitro?.options.dev) {
+        debug("[init] Adding rollup plugins for dev");
+        return [...ctx.rollupConfig?.config.plugins || []];
+      }
+    }
+  };
+}
+function nitroEnv(ctx) {
+  return {
+    name: "nitro:env",
+    sharedDuringBuild: true,
+    apply: (_config, configEnv) => !configEnv.isPreview,
+    async config(userConfig, _configEnv) {
+      debug("[env]  Extending config (environments)");
+      const environments = {
+        ...createServiceEnvironments(ctx),
+        nitro: createNitroEnvironment(ctx)
+      };
+      environments.client = {
+        consumer: userConfig.environments?.client?.consumer ?? "client",
+        build: {
+          rollupOptions: {
+            input: userConfig.environments?.client?.build?.rollupOptions?.input ?? useNitro(ctx).options.renderer?.template
           }
         }
-        if (!ctx.nitro.options.renderer?.entry && !ctx.nitro.options.renderer?.template && ctx.pluginConfig.services.ssr?.entry) {
-          ctx.nitro.options.renderer ??= {};
-          ctx.nitro.options.renderer.entry = resolve(
-            runtimeDir,
-            "internal/vite/ssr-renderer"
-          );
-        }
-        const publicDistDir = ctx._publicDistDir = userConfig.build?.outDir || resolve(ctx.nitro.options.buildDir, "vite/public");
-        ctx.nitro.options.publicAssets.push({
-          dir: publicDistDir,
-          maxAge: 0,
-          baseURL: "/",
-          fallthrough: true
-        });
-        if (!ctx.nitro.options.dev) {
-          ctx.nitro.options.unenv.push({
-            meta: { name: "nitro-vite" },
-            polyfill: ["#nitro-vite-setup"]
-          });
-        }
-        await ctx.nitro.hooks.callHook("build:before", ctx.nitro);
-        ctx.rollupConfig = await getViteRollupConfig(ctx);
-        if (ctx.nitro.options.dev) {
-          await ctx.nitro.hooks.callHook(
-            "rollup:before",
-            ctx.nitro,
-            ctx.rollupConfig.config
-          );
-        }
-        if (ctx.nitro.options.dev && !ctx.devWorker) {
-          ctx.devWorker = createDevWorker(ctx);
+      };
+      debug("[env]  Environments:", Object.keys(environments).join(", "));
+      return {
+        environments
+      };
+    },
+    configEnvironment(name, config) {
+      if (config.consumer === "client") {
+        debug(
+          "[env]  Configuring client environment",
+          name === "client" ? "" : ` (${name})`
+        );
+        config.build.emptyOutDir = false;
+        config.build.outDir = useNitro(ctx).options.output.publicDir;
+      } else {
+        if (ctx.pluginConfig.experimental?.virtualBundle && name in (ctx.pluginConfig.services || {})) {
+          debug("[env]  Configuring service environment for virtual:", name);
+          config.build ??= {};
+          config.build.write = config.build.write ?? false;
         }
-        if (ctx.nitro.options.dev && !ctx.devApp) {
-          ctx.devApp = new NitroDevApp(ctx.nitro);
+      }
+    }
+  };
+}
+function nitroMain(ctx) {
+  return {
+    name: "nitro:main",
+    sharedDuringBuild: true,
+    apply: (_config, configEnv) => !configEnv.isPreview,
+    async config(userConfig, _configEnv) {
+      debug("[main] Extending config (appType, resolve, server)");
+      if (!ctx.rollupConfig) {
+        throw new Error("Nitro rollup config is not initialized yet.");
+      }
+      return {
+        appType: userConfig.appType || "custom",
+        resolve: {
+          // TODO: environment specific aliases not working
+          // https://github.com/vitejs/vite/pull/17583 (seems not effective)
+          alias: ctx.rollupConfig.base.aliases
+        },
+        builder: {
+          sharedConfigBuild: true
+        },
+        server: {
+          port: Number.parseInt(process.env.PORT || "") || userConfig.server?.port || useNitro(ctx).options.devServer?.port || 3e3
         }
-        return {
-          // Don't include HTML middlewares
-          appType: userConfig.appType || "custom",
-          // Add Nitro as a Vite environment
-          environments: {
-            client: {
-              consumer: userConfig.environments?.client?.consumer ?? "client",
-              build: {
-                rollupOptions: {
-                  input: userConfig.environments?.client?.build?.rollupOptions?.input ?? ctx.nitro.options.renderer?.template
-                }
-              }
-            },
-            ...createServiceEnvironments(ctx),
-            nitro: createNitroEnvironment(ctx)
-          },
-          resolve: {
-            // TODO: environment specific aliases not working
-            // https://github.com/vitejs/vite/pull/17583 (seems not effective)
-            alias: ctx.rollupConfig.base.aliases
-          },
-          build: {
-            // TODO: Support server environment emitted assets
-            assetsInlineLimit: 4096 * 4
-          },
-          builder: {
-            /// Share the config instance among environments to align with the behavior of dev server
-            sharedConfigBuild: true
-          },
-          server: {
-            port: Number.parseInt(process.env.PORT || "") || userConfig.server?.port || ctx.nitro.options.devServer?.port || 3e3
-          }
-        };
-      },
-      configResolved(config) {
-        if (config.command === "build") {
-          for (const env of Object.values(config.environments)) {
-            if (env.consumer === "client") {
-              const { assetsDir } = env.build;
-              const rule = ctx.nitro.options.routeRules[`/${assetsDir}/**`] ??= {};
-              if (!rule.headers?.["cache-control"]) {
-                rule.headers = {
-                  ...rule.headers,
-                  "cache-control": `public, max-age=31536000, immutable`
-                };
-              }
+      };
+    },
+    configResolved(config) {
+      if (config.command === "build") {
+        debug("[main] Inferring caching routes");
+        for (const env of Object.values(config.environments)) {
+          if (env.consumer === "client") {
+            const rule = ctx.nitro.options.routeRules[`/${env.build.assetsDir}/**`] ??= {};
+            if (!rule.headers?.["cache-control"]) {
+              rule.headers = {
+                ...rule.headers,
+                "cache-control": `public, max-age=31536000, immutable`
+              };
             }
           }
         }
-        ctx.nitro.routing.sync();
-      },
-      buildApp: {
-        order: "post",
-        handler(builder) {
-          return buildEnvironments(ctx, builder);
-        }
-      },
-      generateBundle: {
-        handler(_options, bundle) {
-          const { root } = this.environment.config;
-          const services = ctx.pluginConfig.services || {};
-          const serviceNames = Object.keys(services);
-          const isRegisteredService = serviceNames.includes(
-            this.environment.name
-          );
-          let entryFile;
-          for (const [_name, file] of Object.entries(bundle)) {
-            if (file.type === "chunk") {
-              if (isRegisteredService && file.isEntry) {
-                if (entryFile !== void 0) {
-                  this.error(
-                    `Multiple entry points found for service "${this.environment.name}". Only one entry point is allowed.`
-                  );
-                }
+      }
+      debug("[main] Syncing nitro routes");
+      ctx.nitro.routing.sync();
+    },
+    buildApp: {
+      order: "post",
+      handler(builder) {
+        debug("[main] Building environments");
+        return buildEnvironments(ctx, builder);
+      }
+    },
+    generateBundle: {
+      handler(_options, bundle) {
+        const environment = this.environment;
+        debug(
+          "[main] Generating manifest and entry points for environment:",
+          environment.name
+        );
+        const { root } = environment.config;
+        const services = ctx.pluginConfig.services || {};
+        const serviceNames = Object.keys(services);
+        const isRegisteredService = serviceNames.includes(environment.name);
+        let entryFile;
+        for (const [_name, file] of Object.entries(bundle)) {
+          if (file.type === "chunk") {
+            if (isRegisteredService && file.isEntry) {
+              if (entryFile === void 0) {
                 entryFile = file.fileName;
-              }
-              const filteredModuleIds = file.moduleIds.filter(
-                (id) => id.startsWith(root)
-              );
-              for (const id of filteredModuleIds) {
-                const originalFile = relative(root, id);
-                ctx._manifest[originalFile] = { file: file.fileName };
+              } else {
+                this.warn(
+                  `Multiple entry points found for service "${environment.name}"`
+                );
               }
             }
-          }
-          if (isRegisteredService) {
-            if (entryFile === void 0) {
-              this.error(
-                `No entry point found for service "${this.environment.name}".`
-              );
+            const filteredModuleIds = file.moduleIds.filter(
+              (id) => id.startsWith(root)
+            );
+            for (const id of filteredModuleIds) {
+              const originalFile = relative(root, id);
+              ctx._manifest[originalFile] = { file: file.fileName };
             }
-            ctx._entryPoints[this.environment.name] = entryFile;
-            ctx._serviceBundles[this.environment.name] = bundle;
           }
         }
-      },
-      // Modify environment configs before it's resolved.
-      configEnvironment(name, config) {
-        if (config.consumer === "client") {
-          config.build.emptyOutDir = false;
-          config.build.outDir = ctx.nitro.options.output.publicDir;
-        }
-        const services = ctx.pluginConfig.services || {};
-        const serviceNames = Object.keys(services);
-        if (serviceNames.includes(name) && ctx.pluginConfig.experimental?.virtualBundle) {
-          config.build ??= {};
-          config.build.write = config.build.write ?? false;
+        if (isRegisteredService) {
+          if (entryFile === void 0) {
+            this.error(
+              `No entry point found for service "${this.environment.name}".`
+            );
+          }
+          ctx._entryPoints[this.environment.name] = entryFile;
+          ctx._serviceBundles[this.environment.name] = bundle;
         }
-      },
-      // Extend Vite dev server with Nitro middleware
-      configureServer: (server) => configureViteDevServer(ctx, server)
+      }
     },
-    {
-      name: "nitro:prepare",
-      buildApp: {
-        // clean the output directory before any environment is built
-        order: "pre",
-        async handler() {
-          const nitro2 = ctx.nitro;
-          await prepare(nitro2);
-        }
+    configureServer: (server) => {
+      debug("[main] Configuring dev server");
+      return configureViteDevServer(ctx, server);
+    }
+  };
+}
+function nitroPrepare(ctx) {
+  return {
+    name: "nitro:prepare",
+    sharedDuringBuild: true,
+    applyToEnvironment: (env) => env.name === "nitro",
+    buildApp: {
+      // Clean the output directory before any environment is built
+      order: "pre",
+      async handler() {
+        debug("[prepare] Preparing output directory");
+        const nitro2 = ctx.nitro;
+        await prepare(nitro2);
       }
     }
-  ];
+  };
 }
-function nitroServicePlugin(ctx) {
+function nitroService(ctx) {
   return {
     name: "nitro:service",
     enforce: "pre",
-    // Only apply this plugin to the nitro environment
+    sharedDuringBuild: true,
     applyToEnvironment: (env) => env.name === "nitro",
     resolveId: {
       async handler(id, importer, options) {
@@ -928,43 +1447,95 @@ function nitroServicePlugin(ctx) {
     }
   };
 }
-function nitroRollupPlugins(ctx) {
-  const createHookCaller = (hook, order) => {
-    const handler = async function(...args) {
-      for (const plugin of ctx.rollupConfig.config.plugins) {
-        if (typeof plugin[hook] !== "function") continue;
-        let res;
-        try {
-          res = await plugin[hook].call(this, ...args);
-        } catch (error) {
-          throw new Error(
-            `[nitro] Calling rollup plugin ${plugin.name || "unknown"}.${hook} failed`,
-            { cause: error }
-          );
-        }
-        if (res) {
-          if (hook === "resolveId" && res.id?.startsWith?.("file://")) {
-            res.id = fileURLToPath(res.id);
-          }
-          return res;
-        }
-      }
-    };
-    Object.defineProperty(handler, "name", { value: hook });
-    return order ? { order, handler } : handler;
-  };
+function createContext(pluginConfig) {
   return {
-    name: "nitro:rollup-hooks",
-    applyToEnvironment: (env) => env.name === "nitro",
-    buildStart: createHookCaller("buildStart", "pre"),
-    resolveId: createHookCaller("resolveId", "pre"),
-    load: createHookCaller("load", "pre"),
-    transform: createHookCaller("transform", "post"),
-    renderChunk: createHookCaller("renderChunk", "post"),
-    generateBundle: createHookCaller("generateBundle", "post"),
-    buildEnd: createHookCaller("buildEnd", "post")
+    pluginConfig,
+    _entryPoints: {},
+    _manifest: {},
+    _serviceBundles: {}
   };
 }
+function useNitro(ctx) {
+  if (!ctx.nitro) {
+    throw new Error("Nitro instance is not initialized yet.");
+  }
+  return ctx.nitro;
+}
+async function setupNitroContext(ctx, configEnv, userConfig) {
+  ctx.nitro = ctx.pluginConfig._nitro || await createNitro({
+    dev: configEnv.mode === "development",
+    rootDir: userConfig.root,
+    ...defu(ctx.pluginConfig.config, userConfig.nitro)
+  });
+  if (!ctx.pluginConfig.services?.ssr) {
+    ctx.pluginConfig.services ??= {};
+    if (userConfig.environments?.ssr === void 0) {
+      const ssrEntry = resolveModulePath("./entry-server", {
+        from: ["", "app", "src"].flatMap(
+          (d) => ctx.nitro.options.scanDirs.map((s) => join(s, d) + "/")
+        ),
+        extensions: DEFAULT_EXTENSIONS,
+        try: true
+      });
+      if (ssrEntry) {
+        ctx.pluginConfig.services.ssr = { entry: ssrEntry };
+        ctx.nitro.logger.info(
+          `Using \`${prettyPath(ssrEntry)}\` as vite ssr entry.`
+        );
+      }
+    } else {
+      let ssrEntry = getEntry(
+        userConfig.environments.ssr.build?.rollupOptions?.input
+      );
+      if (typeof ssrEntry === "string") {
+        ssrEntry = resolveModulePath(ssrEntry, {
+          from: ctx.nitro.options.scanDirs,
+          extensions: DEFAULT_EXTENSIONS,
+          suffixes: ["", "/index"],
+          try: true
+        }) || ssrEntry;
+        ctx.pluginConfig.services.ssr = { entry: ssrEntry };
+      } else {
+        throw new TypeError(`Invalid input type for SSR entry point.`);
+      }
+    }
+  }
+  if (!ctx.nitro.options.renderer?.entry && !ctx.nitro.options.renderer?.template && ctx.pluginConfig.services.ssr?.entry) {
+    ctx.nitro.options.renderer ??= {};
+    ctx.nitro.options.renderer.entry = resolve(
+      runtimeDir,
+      "internal/vite/ssr-renderer"
+    );
+  }
+  const publicDistDir = ctx._publicDistDir = userConfig.build?.outDir || resolve(ctx.nitro.options.buildDir, "vite/public");
+  ctx.nitro.options.publicAssets.push({
+    dir: publicDistDir,
+    maxAge: 0,
+    baseURL: "/",
+    fallthrough: true
+  });
+  if (!ctx.nitro.options.dev) {
+    ctx.nitro.options.unenv.push({
+      meta: { name: "nitro-vite" },
+      polyfill: ["#nitro-vite-setup"]
+    });
+  }
+  await ctx.nitro.hooks.callHook("build:before", ctx.nitro);
+  ctx.rollupConfig = await getViteRollupConfig(ctx);
+  if (ctx.nitro.options.dev) {
+    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;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { d as copyPublicAssets, i as createNitro, D as listTasks, A as loadOptions, j as prepare, B as runTask } from './_chunks/index.mjs';
+export { d as copyPublicAssets, k as createNitro, E as listTasks, B as loadOptions, j as prepare, D as runTask } from './_chunks/index.mjs';
 export { b as build, p as prerender, w as writeTypes } from './_chunks/index3.mjs';
 export { c as createDevServer } from './_chunks/server.mjs';
 import 'consola';

package/dist/presets.mjs

@@ -1,4 +1,4 @@
-import { b as glob, Q as findNearestFile, h, R as readGitConfig, S as readPackageJSON, r as resolveModulePath, T as findFile, U as fileURLToPath, V as resolveCompatibilityDatesFromEnv, f as formatCompatibilityDate } from './_chunks/index.mjs';
+import { b as glob, R as findNearestFile, h, S as readGitConfig, T as readPackageJSON, r as resolveModulePath, U as findFile, V as fileURLToPath, W as resolveCompatibilityDatesFromEnv, f as formatCompatibilityDate } from './_chunks/index.mjs';
 import { kebabCase } from 'scule';
 import { provider, isTest } from 'std-env';
 import { presetsDir, runtimeDir } from 'nitro/runtime/meta';

package/dist/vite.d.mts

@@ -28,6 +28,11 @@ interface NitroPluginConfig {
          * @note This is unsafe if plugins rely on temporary files on the filesystem.
          */
         virtualBundle?: boolean;
+        /**
+         * @experimental Enable `?assets` import proposed by https://github.com/vitejs/vite/discussions/20913
+         * @default true
+         */
+        assetsImport?: boolean;
     };
 }
 interface ServiceConfig {

package/dist/vite.mjs

@@ -66,3 +66,4 @@ import 'rendu';
 import 'vite';
 import 'get-port-please';
 import 'node:child_process';
+import 'node:assert/strict';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitro-nightly",
-  "version": "3.0.1-20251023-220447-2d199369",
+  "version": "3.1.0-20251024-111905-4718bf73",
   "description": "Build and Deploy Universal JavaScript Servers",
   "homepage": "https://nitro.build",
   "repository": "nitrojs/nitro",
@@ -75,6 +75,7 @@
     "@azure/static-web-apps-cli": "^2.0.7",
     "@cloudflare/workers-types": "^4.20251014.0",
     "@deno/types": "^0.0.1",
+    "@hiogawa/vite-plugin-fullstack": "0.0.5",
     "@netlify/edge-functions": "^3.0.1",
     "@netlify/functions": "^5.0.1",
     "@rollup/plugin-alias": "^5.1.1",