nitro-nightly 3.0.1-20251024-104739-fa2c167d → 3.1.0-20251024-135426-4da5803f

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, prepare as i, createNitro 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 { j 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 prepare, j as createNitro } from './index.mjs';
-import 'node:url';
+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,6 +639,569 @@ 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 "virtual:fullstack/runtime";\n`);
+						replacement = `__assets_runtime.mergeAssets(${importedNames.join(", ")})`;
+					}
+					output.update(start, end, `(${replacement})`);
+				}
+				if (output.hasChanged()) {
+					for (const newImport of newImports) output.append(newImport);
+					return {
+						code: output.toString(),
+						map: output.generateMap({ hires: "boundary" })
+					};
+				}
+			} },
+			resolveId: { handler(source) {
+				if (source.startsWith("virtual:fullstack/assets?")) return "\0" + source;
+				if (source === "virtual:fullstack/assets-manifest") {
+					assert.notEqual(this.environment.name, "client");
+					assert.equal(this.environment.mode, "build");
+					return {
+						id: source,
+						external: true
+					};
+				}
+				if (source === "virtual:fullstack/runtime") return { id: source };
+			} },
+			load: { async handler(id) {
+				if (id === "virtual:fullstack/runtime") return runtimeUtils();
+				const parsed = parseAssetsVirtual(id);
+				if (!parsed) return;
+				assert.notEqual(this.environment.name, "client");
+				const resolved = await this.resolve(parsed.import, parsed.importer);
+				assert(resolved, `Failed to resolve: ${parsed.import}`);
+				const s = new MagicString("");
+				const code = await processAssetsImport(this, resolved.id, {
+					environment: parsed.environment,
+					isEntry: !!parsed.entry
+				});
+				s.append(`export default ${code};\n`);
+				if (this.environment.mode === "build") s.prepend(`import __assets_manifest from "virtual:fullstack/assets-manifest";\n`);
+				return s.toString();
+			} },
+			renderChunk(code, chunk) {
+				if (code.includes("virtual:fullstack/assets-manifest")) {
+					const replacement = normalizeRelativePath(path.relative(path.join(chunk.fileName, ".."), BUILD_ASSETS_MANIFEST_NAME));
+					code = code.replaceAll("virtual:fullstack/assets-manifest", () => replacement);
+					return { code };
+				}
+				return;
+			},
+			writeBundle(_options, bundle) {
+				bundleMap[this.environment.name] = bundle;
+			},
+			buildStart() {
+				if (this.environment.mode == "build" && this.environment.name === "client") {
+					const metas = importAssetsMetaMap["client"];
+					if (metas) {
+						for (const meta of Object.values(importAssetsMetaMap["client"])) if (meta.isEntry) this.emitFile({
+							type: "chunk",
+							id: meta.id,
+							preserveSignature: "exports-only"
+						});
+					}
+				}
+			},
+			buildApp: {
+				order: "pre",
+				async handler(builder) {
+					builder.writeAssetsManifest = async () => {
+						await writeAssetsManifest(builder);
+					};
+				}
+			}
+		},
+		{
+			name: "fullstack:write-assets-manifest-post",
+			buildApp: {
+				order: "post",
+				async handler(builder) {
+					await builder.writeAssetsManifest();
+				}
+			}
+		},
+		{
+			name: "fullstack:assets-query",
+			sharedDuringBuild: true,
+			resolveId: {
+				order: "pre",
+				handler(source) {
+					const { query } = parseIdQuery(source);
+					const value = query["assets"];
+					if (typeof value !== "undefined") {
+						if (this.environment.name === "client") return `\0virtual:fullstack/empty-assets`;
+					}
+					if (source === "virtual:fullstack/runtime") return source;
+				}
+			},
+			load: { async handler(id) {
+				if (id === "\0virtual:fullstack/empty-assets") return `export default ${JSON.stringify(EMPTY_ASSETS)}`;
+				if (id === "virtual:fullstack/runtime") return runtimeUtils();
+				const { filename, query } = parseIdQuery(id);
+				const value = query["assets"];
+				if (typeof value !== "undefined") {
+					const s = new MagicString("");
+					const codes = [];
+					if (value) {
+						const code = await processAssetsImport(this, filename, {
+							environment: value,
+							isEntry: value === "client"
+						});
+						codes.push(code);
+					} else {
+						const code1 = await processAssetsImport(this, filename, {
+							environment: "client",
+							isEntry: false
+						});
+						const code2 = await processAssetsImport(this, filename, {
+							environment: this.environment.name,
+							isEntry: false
+						});
+						codes.push(code1, code2);
+					}
+					s.append(`
+import * as __assets_runtime from "virtual:fullstack/runtime";\n
+export default __assets_runtime.mergeAssets(${codes.join(", ")});
+`);
+					if (this.environment.mode === "build") s.prepend(`import __assets_manifest from "virtual:fullstack/assets-manifest";\n`);
+					return {
+						code: s.toString(),
+						moduleSideEffects: false
+					};
+				}
+			} },
+			hotUpdate(ctx) {
+				if (this.environment.name === "rsc") {
+					const mods = collectModuleDependents(ctx.modules);
+					for (const mod of mods) if (mod.id) {
+						const ids = [
+							`${mod.id}?assets`,
+							`${mod.id}?assets=client`,
+							`${mod.id}?assets=${this.environment.name}`
+						];
+						for (const id of ids) invalidteModuleById(this.environment, id);
+					}
+				}
+			}
+		},
+		{
+			...createVirtualPlugin("fullstack/client-fallback", () => "export {}"),
+			configEnvironment: {
+				order: "post",
+				handler(name, config, _env) {
+					if (name === "client") {
+						const clientBuildFallback = pluginOpts?.experimental?.clientBuildFallback ?? true;
+						if (clientBuildFallback && !config.build?.rollupOptions?.input) return { build: { rollupOptions: { input: { __fallback: "virtual:fullstack/client-fallback" } } } };
+					}
+				}
+			},
+			generateBundle(_optoins, bundle) {
+				if (this.environment.name !== "client") return;
+				for (const [k, v] of Object.entries(bundle)) if (v.type === "chunk" && v.name === "__fallback") delete bundle[k];
+			}
+		},
+		patchViteClientPlugin(),
+		patchVueScopeCssHmr(),
+		patchCssLinkSelfAccept()
+	];
+}
+const EMPTY_ASSETS = {
+	js: [],
+	css: []
+};
+const BUILD_ASSETS_MANIFEST_NAME = "__fullstack_assets_manifest.js";
+async function collectCss(environment, entryId, options) {
+	const visited = /* @__PURE__ */ new Set();
+	const cssIds = /* @__PURE__ */ new Set();
+	async function recurse(id) {
+		if (visited.has(id) || parseAssetsVirtual(id) || "assets" in parseIdQuery(id).query) return;
+		visited.add(id);
+		const mod = environment.moduleGraph.getModuleById(id);
+		if (!mod) return;
+		if (options.eager && !mod?.transformResult) try {
+			await environment.transformRequest(id);
+		} catch (e) {
+			console.error(`[collectCss] Failed to transform '${id}'`, e);
+		}
+		for (const next of mod?.importedModules ?? []) if (next.id) if (isCSSRequest(next.id)) {
+			if (hasSpecialCssQuery(next.id)) continue;
+			cssIds.add(next.id);
+		} else await recurse(next.id);
+	}
+	await recurse(entryId);
+	const hrefs = [...cssIds].map((id) => normalizeViteImportAnalysisUrl(environment, id));
+	return {
+		ids: [...cssIds],
+		hrefs
+	};
+}
+function invalidteModuleById(environment, id) {
+	const mod = environment.moduleGraph.getModuleById(id);
+	if (mod) environment.moduleGraph.invalidateModule(mod);
+	return mod;
+}
+function collectModuleDependents(mods) {
+	const visited = /* @__PURE__ */ new Set();
+	function recurse(mod) {
+		if (visited.has(mod)) return;
+		visited.add(mod);
+		for (const importer of mod.importers) recurse(importer);
+	}
+	for (const mod of mods) recurse(mod);
+	return [...visited];
+}
+function hasSpecialCssQuery(id) {
+	return /[?&](url|inline|raw)(\b|=|&|$)/.test(id);
+}
+function collectAssetDeps(bundle) {
+	const chunkToDeps = /* @__PURE__ */ new Map();
+	for (const chunk of Object.values(bundle)) if (chunk.type === "chunk") chunkToDeps.set(chunk, collectAssetDepsInner(chunk.fileName, bundle));
+	const idToDeps = {};
+	for (const [chunk, deps] of chunkToDeps.entries()) for (const id of chunk.moduleIds) idToDeps[id] = {
+		chunk,
+		deps
+	};
+	return idToDeps;
+}
+function collectAssetDepsInner(fileName, bundle) {
+	const visited = /* @__PURE__ */ new Set();
+	const css = [];
+	function recurse(k) {
+		if (visited.has(k)) return;
+		visited.add(k);
+		const v = bundle[k];
+		assert(v, `Not found '${k}' in the bundle`);
+		if (v.type === "chunk") {
+			css.push(...v.viteMetadata?.importedCss ?? []);
+			for (const k2 of v.imports) if (k2 in bundle) recurse(k2);
+		}
+	}
+	recurse(fileName);
+	return {
+		js: [...visited],
+		css: [...new Set(css)]
+	};
+}
+function patchViteClientPlugin() {
+	const viteClientPath = normalizePath(fileURLToPath(import.meta.resolve("vite/dist/client/client.mjs")));
+	function endIndexOf(code, searchValue) {
+		const i = code.lastIndexOf(searchValue);
+		return i === -1 ? i : i + searchValue.length;
+	}
+	return {
+		name: "fullstack:patch-vite-client",
+		transform: { handler(code, id) {
+			if (id === viteClientPath) {
+				if (code.includes("linkSheetsMap")) return;
+				const s = new MagicString(code);
+				s.prependLeft(code.indexOf("const sheetsMap"), `\
+const linkSheetsMap = new Map();
+document
+  .querySelectorAll('link[rel="stylesheet"][data-vite-dev-id]')
+  .forEach((el) => {
+    linkSheetsMap.set(el.getAttribute('data-vite-dev-id'), el)
+  });
+`);
+				s.appendLeft(endIndexOf(code, `function updateStyle(id, content) {`), `if (linkSheetsMap.has(id)) { return }`);
+				s.appendLeft(endIndexOf(code, `function removeStyle(id) {`), `
+const link = linkSheetsMap.get(id);
+if (link) {
+  document
+    .querySelectorAll(
+      'link[rel="stylesheet"][data-vite-dev-id]',
+    )
+    .forEach((el) => {
+      if (el.getAttribute('data-vite-dev-id') === id) {
+        el.remove()
+      }
+    })
+  linkSheetsMap.delete(id)
+}
+`);
+				return s.toString();
+			}
+		} }
+	};
+}
+function patchVueScopeCssHmr() {
+	return {
+		name: "fullstack:patch-vue-scoped-css-hmr",
+		configureServer(server) {
+			server.middlewares.use((req, _res, next) => {
+				if (req.headers.accept?.includes("text/css") && req.url?.includes("&lang.css=")) req.url = req.url.replace("&lang.css=", "?lang.css");
+				next();
+			});
+		}
+	};
+}
+function patchCssLinkSelfAccept() {
+	return {
+		name: "fullstack:patch-css-link-self-accept",
+		apply: "serve",
+		transform: {
+			order: "post",
+			handler(_code, id, _options) {
+				if (this.environment.name === "client" && this.environment.mode === "dev" && isCSSRequest(id) && directRequestRE.test(id)) {
+					const mod = this.environment.moduleGraph.getModuleById(id);
+					if (mod && !mod.isSelfAccepting) mod.isSelfAccepting = true;
+				}
+			}
+		}
+	};
+}
+function runtimeUtils() {
+	return `
+export function mergeAssets(...args) {
+  const js = uniqBy(args.flatMap((h) => h.js), (a) => a.href);
+  const css = uniqBy(args.flatMap((h) => h.css), (a) => a.href);
+  const entry = args.filter((arg) => arg.entry)?.[0]?.entry;
+  const raw = { entry, js, css };
+  return { ...raw, merge: (...args$1) => mergeAssets(raw, ...args$1) };
+}
+function uniqBy(array, key) {
+  const seen = new Set();
+  return array.filter((item) => {
+    const k = key(item);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}`;
+}
+
 const DEFAULT_EXTENSIONS = [".ts", ".js", ".mts", ".mjs", ".tsx", ".jsx"];
 const debug = process.env.NITRO_DEBUG ? (...args) => console.log("[nitro]", ...args) : () => {
 };
@@ -646,7 +1213,13 @@ function nitro(pluginConfig = {}) {
     nitroMain(ctx),
     nitroPrepare(ctx),
     nitroService(ctx),
-    nitroPreviewPlugin()
+    nitroPreviewPlugin(),
+    pluginConfig.experimental?.assetsImport !== false && assetsPlugin({
+      experimental: {
+        // See https://github.com/hi-ogawa/vite-plugins/pull/1289
+        clientBuildFallback: false
+      }
+    })
   ];
 }
 function nitroInit(ctx) {

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { d as copyPublicAssets, j as createNitro, D as listTasks, A as loadOptions, i 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-20251024-104739-fa2c167d",
+  "version": "3.1.0-20251024-135426-4da5803f",
   "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": "npm:@pi0/vite-plugin-fullstack",
     "@netlify/edge-functions": "^3.0.1",
     "@netlify/functions": "^5.0.1",
     "@rollup/plugin-alias": "^5.1.1",