@depup/nuxt__kit 4.5.1-depup.0 → 4.5.2-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/nuxt__kit
 
 | Field | Value |
 |-------|-------|
-| Original | [@nuxt/kit](https://www.npmjs.com/package/@nuxt/kit) @ 4.5.1 |
-| Processed | 2026-07-27 |
+| Original | [@nuxt/kit](https://www.npmjs.com/package/@nuxt/kit) @ 4.5.2 |
+| Processed | 2026-08-05 |
 | Smoke test | passed |
 | Deps updated | 2 |
 
@@ -23,7 +23,7 @@ npm install @depup/nuxt__kit
 | Dependency | From | To |
 |------------|------|-----|
 | c12 | ^3.3.4 | ^4.0.0-beta.5 |
-| verkit | ^0.2.0 | ^0.3.1 |
+| verkit | ^0.3.1 | ^0.3.2 |
 
 ---
 

package/changes.json

@@ -5,10 +5,10 @@
       "to": "^4.0.0-beta.5"
     },
     "verkit": {
-      "from": "^0.2.0",
-      "to": "^0.3.1"
+      "from": "^0.3.1",
+      "to": "^0.3.2"
     }
   },
-  "timestamp": "2026-07-27T16:43:41.446Z",
+  "timestamp": "2026-08-05T16:34:27.674Z",
   "totalUpdated": 2
 }

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { ConsolaInstance, ConsolaOptions } from "consola";
 import { UseContext } from "unctx";
+import "pkg-types";
 import { GlobOptions } from "tinyglobby";
 import { LoadConfigOptions } from "c12";
 import { Component, ComponentsDir, ModuleDefinition, ModuleMeta, ModuleOptions, Nuxt, NuxtAppConfig, NuxtBuildOutputs, NuxtCompatibility, NuxtCompatibilityIssues, NuxtConfig, NuxtHooks, NuxtMiddleware, NuxtModule, NuxtOptions, NuxtPlugin, NuxtPluginTemplate, NuxtServerTemplate, NuxtTemplate, NuxtTypeTemplate, ResolvedNuxtTemplate, SchemaDefinition } from "@nuxt/schema";
@@ -7,7 +8,6 @@ import { Import, Preset } from "unimport";
 import { Configuration, WebpackPluginInstance } from "webpack";
 import { Plugin, UserConfig } from "vite";
 import { Nitro, NitroDevEventHandler, NitroEventHandler, NitroRouteConfig } from "nitropack/types";
-
 //#region src/module/define.d.ts
 /**
  * Define a Nuxt module, automatically merging defaults with user provided options, installing
@@ -581,6 +581,35 @@ declare function packageName(specifier: string): string;
  */
 declare function resolveTypePaths(packages: string[], searchPaths: string[]): Promise<Array<[string, string]>>;
 //#endregion
+//#region src/watch.d.ts
+/**
+ * The subset of a chokidar `FSWatcher` this helper needs. Callers hold
+ * different chokidar majors (Nuxt core watches with v5, Vite bundles v3), so
+ * the parameter is structural rather than an import of either package.
+ */
+interface RecoverableWatcher {
+  on: (event: any, listener: (...args: any[]) => void) => any;
+  emit: (event: any, ...args: any[]) => any;
+  options?: {
+    cwd?: string | undefined;
+  } | undefined;
+}
+/**
+ * chokidar suppresses a `change` event that lands within 50ms of the previous
+ * `change` for the same path, and never replays it. A save that follows a fast
+ * HMR round trip is therefore silently lost until the file is touched again,
+ * which looks exactly like broken HMR. This is true of every chokidar major
+ * Nuxt uses.
+ *
+ * Raw fs events are not throttled, so once chokidar has reported a file at
+ * least once we can use them to notice a modification that never surfaced as a
+ * `change` event, and re-emit it after the throttle window has passed.
+ *
+ * @param watcher the chokidar watcher to patch
+ * @returns a disposer releasing the recovery state; call it when the watcher closes
+ */
+declare function recoverThrottledChanges(watcher: RecoverableWatcher): () => void;
+//#endregion
 //#region src/logger.d.ts
 declare const logger: ConsolaInstance;
 declare function useLogger(tag?: string, options?: Partial<ConsolaOptions>): ConsolaInstance;
@@ -1008,6 +1037,16 @@ declare const pageDiagnostics: import("nostics").Diagnostics<{
     readonly fix: "Use only JSON-serializable values (strings, numbers, booleans, arrays, plain objects) in `defineRouteRules()`.";
     readonly docs: false;
   };
+  readonly NUXT_B4007: {
+    readonly why: (p: {
+      fnName: string;
+      file: string;
+    }) => string;
+    readonly fix: (p: {
+      fnName: string;
+    }) => string;
+    readonly docs: false;
+  };
   readonly NUXT_B4008: {
     readonly why: "Server pages with `ssr: false` are not supported while component islands are auto-detected.";
     readonly fix: "Set `experimental.componentIslands` to `true`.";
@@ -1335,6 +1374,18 @@ declare const bundlerDiagnostics: import("nostics").Diagnostics<{
     readonly fix: "Externalize dependencies in the server build (`externals`) for better build performance.";
     readonly docs: false;
   };
+  readonly NUXT_B7020: {
+    readonly why: "The client build manifest is disabled, but Nuxt requires it to render the correct assets for each route.";
+    readonly fix: "Remove any `build.manifest: false` override from your `nuxt.config` `vite` options or from a Vite plugin `config`/`configEnvironment` hook.";
+    readonly docs: false;
+  };
+  readonly NUXT_B7021: {
+    readonly why: (p: {
+      manifestFile: string;
+    }) => string;
+    readonly fix: "Check that no Vite plugin removes or renames the client build manifest in a `generateBundle`/`writeBundle` hook. If this happens with no such plugin, please report it at https://github.com/nuxt/nuxt/issues.";
+    readonly docs: false;
+  };
 }, readonly [import("nostics").DiagnosticReporter<{
   method?: import("nostics").ConsoleMethod;
 }>]>;
@@ -1373,4 +1424,4 @@ declare function requireModule<T = unknown>(id: string, opts?: ImportModuleOptio
  */
 declare function tryRequireModule<T = unknown>(id: string, opts?: ImportModuleOptions): T | undefined;
 //#endregion
-export { type AddComponentOptions, type AddPluginOptions, type AddRouteMiddlewareOptions, DEFAULT_JSX_FILE_EXTENSIONS, DEFAULT_JS_FILE_EXTENSIONS, type ExtendConfigOptions, type ExtendRouteRulesOptions, type ExtendViteConfigOptions, type ExtendWebpackConfigOptions, type ImportModuleOptions, type LayerDirectories, type LoadNuxtConfigOptions, type LoadNuxtOptions, type NuxtMajorVersion, type ResolveModuleOptions, type ResolvePathOptions, type Resolver, addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildDiagnostics, buildNuxt, bundlerDiagnostics, checkNuxtCompatibility, componentDiagnostics, configDiagnostics, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getLayerDirectories, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, headDiagnostics, importModule, installModule, installModules, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, packageName, pageDiagnostics, pluginDiagnostics, requireModule, resolveAlias, resolveDeclarationPath, resolveFiles, resolveIgnorePatterns, resolveModule, resolveModuleWithOptions, resolveNuxtModule, resolvePath, resolveTypePaths, runWithNuxtContext, setBuildOutput, setGlobalHead, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateAppConfig, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
+export { type AddComponentOptions, type AddPluginOptions, type AddRouteMiddlewareOptions, DEFAULT_JSX_FILE_EXTENSIONS, DEFAULT_JS_FILE_EXTENSIONS, type ExtendConfigOptions, type ExtendRouteRulesOptions, type ExtendViteConfigOptions, type ExtendWebpackConfigOptions, type ImportModuleOptions, type LayerDirectories, type LoadNuxtConfigOptions, type LoadNuxtOptions, type NuxtMajorVersion, type RecoverableWatcher, type ResolveModuleOptions, type ResolvePathOptions, type Resolver, addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildDiagnostics, buildNuxt, bundlerDiagnostics, checkNuxtCompatibility, componentDiagnostics, configDiagnostics, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getLayerDirectories, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, headDiagnostics, importModule, installModule, installModules, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, packageName, pageDiagnostics, pluginDiagnostics, recoverThrottledChanges, requireModule, resolveAlias, resolveDeclarationPath, resolveFiles, resolveIgnorePatterns, resolveModule, resolveModuleWithOptions, resolveNuxtModule, resolvePath, resolveTypePaths, runWithNuxtContext, setBuildOutput, setGlobalHead, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateAppConfig, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };

package/dist/index.mjs

@@ -1,6 +1,5 @@
 import { performance } from "node:perf_hooks";
 import { createDefu, defu } from "defu";
-import { applyDefaults } from "untyped";
 import { consola } from "consola";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { getContext } from "unctx";
@@ -13,22 +12,23 @@ import { readPackageJSON, resolvePackageJSON } from "pkg-types";
 import { existsSync, lstatSync, promises, readFileSync, realpathSync, statSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { basename, dirname, isAbsolute, join, normalize, parse, relative, resolve } from "pathe";
-import { createJiti } from "jiti";
 import { interopDefault, lookupNodeModuleSubpath, parseNodeModulePath, resolveModuleExportNames } from "mlly";
 import { resolveModulePath, resolveModuleURL } from "exsolve";
 import { isRelative, withTrailingSlash, withoutTrailingSlash } from "ufo";
 import { read, update } from "rc9";
+import { createJiti } from "jiti";
 import { captureStackTrace } from "errx";
 import { glob } from "tinyglobby";
 import { resolveAlias as resolveAlias$1, reverseResolveAlias } from "pathe/utils";
 import ignore from "ignore";
+import { applyDefaults } from "untyped";
 import { loadConfig, setupDotenv } from "c12";
-import { klona } from "klona/full";
+import { klona } from "klona";
 import destr from "destr";
 import { kebabCase, pascalCase, snakeCase } from "scule";
-import { klona as klona$1 } from "klona";
 import { hash } from "ohash";
-import { isAbsolute as isAbsolute$1 } from "node:path";
+import { isAbsolute as isAbsolute$1, join as join$1, resolve as resolve$1 } from "node:path";
+import { stat } from "node:fs/promises";
 //#region src/logger.ts
 const logger = consola;
 function useLogger(tag, options = {}) {
@@ -209,7 +209,8 @@ const builderMap = {
 	"@nuxt/webpack-builder": "webpack"
 };
 function checkNuxtVersion(version, nuxt = useNuxt()) {
-	return satisfies(normalizeSemanticVersion(getNuxtVersion(nuxt)), version, { includePrerelease: true });
+	const nuxtVersion = getNuxtVersion(nuxt);
+	return satisfies(normalizeSemanticVersion(nuxtVersion), version, { includePrerelease: true });
 }
 /**
 * Check version constraints and return incompatibility issues as an array
@@ -305,8 +306,13 @@ function _defineNuxtModule(definition) {
 	module.meta.configKey ||= module.meta.name;
 	async function getOptions(inlineOptions, nuxt = useNuxt()) {
 		const nuxtConfigOptionsKey = module.meta.configKey || module.meta.name;
-		let options = defu(inlineOptions, nuxtConfigOptionsKey && nuxtConfigOptionsKey in nuxt.options ? nuxt.options[nuxtConfigOptionsKey] : {}, module.defaults instanceof Function ? await module.defaults(nuxt) : module.defaults ?? {});
-		if (module.schema) options = await applyDefaults(module.schema, options);
+		const nuxtConfigOptions = nuxtConfigOptionsKey && nuxtConfigOptionsKey in nuxt.options ? nuxt.options[nuxtConfigOptionsKey] : {};
+		const optionsDefaults = module.defaults instanceof Function ? await module.defaults(nuxt) : module.defaults ?? {};
+		let options = defu(inlineOptions, nuxtConfigOptions, optionsDefaults);
+		if (module.schema) {
+			const { applyDefaults } = await import("untyped");
+			options = await applyDefaults(module.schema, options);
+		}
 		return Promise.resolve(options);
 	}
 	function getModuleDependencies(nuxt = useNuxt()) {
@@ -692,7 +698,8 @@ function resolveModule(id, options) {
 	});
 }
 async function importModule(id, opts) {
-	return await import(pathToFileURL(resolveModule(id, opts)).href).then((r) => opts?.interopDefault !== false ? interopDefault(r) : r);
+	const resolvedPath = resolveModule(id, opts);
+	return await import(pathToFileURL(resolvedPath).href).then((r) => opts?.interopDefault !== false ? interopDefault(r) : r);
 }
 function tryImportModule(id, opts) {
 	try {
@@ -768,7 +775,8 @@ async function installModules(modulesToInstall, resolvedModulePaths, nuxt = useN
 				continue;
 			}
 			if (value.version) {
-				const pkg = await readPackageJSON(name, { from: [res.resolvedModulePath, ...nuxt.options.modulesDir].filter(Boolean) }).catch(() => null);
+				const resolvePaths = [res.resolvedModulePath, ...nuxt.options.modulesDir].filter(Boolean);
+				const pkg = await readPackageJSON(name, { from: resolvePaths }).catch(() => null);
 				if (pkg?.version && !satisfies(pkg.version, value.version, { includePrerelease: true })) {
 					const message = `Module \`${name}\` version (\`${pkg.version}\`) does not satisfy \`${value.version}\` (requested by ${moduleToAttribute}).`;
 					error = new TypeError(message);
@@ -896,7 +904,7 @@ function getSharedJiti(nuxt) {
 	_jitiCache ||= /* @__PURE__ */ new WeakMap();
 	let jiti = _jitiCache.get(nuxt);
 	if (!jiti) {
-		jiti = createJiti(nuxt.options.rootDir, { alias: nuxt.options.alias });
+		jiti = import("jiti").then(({ createJiti }) => createJiti(nuxt.options.rootDir, { alias: nuxt.options.alias }));
 		_jitiCache.set(nuxt, jiti);
 	}
 	return jiti;
@@ -908,7 +916,7 @@ async function loadNuxtModuleInstance(nuxtModule, nuxt = useNuxt()) {
 		buildTimeModuleMeta
 	};
 	if (typeof nuxtModule !== "string") throw kitDiagnostics.NUXT_B8015({ received: `${typeof nuxtModule} (${JSON.stringify(nuxtModule)})` });
-	const jiti = getSharedJiti(nuxt);
+	const jiti = await getSharedJiti(nuxt);
 	nuxtModule = resolveAlias(nuxtModule, nuxt.options.alias);
 	if (isRelative(nuxtModule)) nuxtModule = resolve(nuxt.options.rootDir, nuxtModule);
 	let src;
@@ -1448,7 +1456,7 @@ function addServerScanDir(dirs, opts = {}) {
 */
 function useRuntimeConfig() {
 	const nuxt = useNuxt();
-	return applyEnv(klona$1(nuxt.options.nitro.runtimeConfig), {
+	return applyEnv(klona(nuxt.options.nitro.runtimeConfig), {
 		prefix: "NITRO_",
 		altPrefix: "NUXT_",
 		envExpansion: nuxt.options.nitro.experimental?.envExpansion ?? !!process.env.NITRO_ENV_EXPANSION
@@ -1581,14 +1589,18 @@ function addVitePlugin(pluginOrGetter, options = {}) {
 			return;
 		}
 		const environmentName = options.server === false ? "client" : "ssr";
-		const pluginName = plugin.map((p) => p.name).join("|");
-		config.plugins.push({
-			name: `${pluginName}:wrapper`,
-			enforce: options?.prepend ? "pre" : "post",
-			applyToEnvironment(environment) {
-				if (environment.name === environmentName) return plugin;
-			}
-		});
+		const defaultEnforce = options?.prepend ? "pre" : "post";
+		const method = options?.prepend ? "unshift" : "push";
+		for (const [enforce, plugins] of groupByEnforce(plugin, defaultEnforce)) {
+			const pluginName = plugins.map((p) => p.name).join("|");
+			config.plugins[method]({
+				name: `${pluginName}:wrapper`,
+				enforce,
+				applyToEnvironment(environment) {
+					if (environment.name === environmentName) return resolveNestedPlugins(plugins, config, environment, nuxt);
+				}
+			});
+		}
 	});
 	nuxt.hook("vite:extendConfig", async (config, env) => {
 		if (!needsEnvInjection) return;
@@ -1598,6 +1610,53 @@ function addVitePlugin(pluginOrGetter, options = {}) {
 		if (env.isServer && options.client === false) config.plugins[method](...plugin);
 	});
 }
+function groupByEnforce(plugins, defaultEnforce) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const plugin of plugins) {
+		const enforce = plugin.enforce ?? defaultEnforce;
+		const group = groups.get(enforce);
+		if (group) group.push(plugin);
+		else groups.set(enforce, [plugin]);
+	}
+	return groups;
+}
+/**
+* Vite only honours `apply` and `applyToEnvironment` for plugins it finds in the
+* top-level plugin array, so plugins nested behind a wrapper have to be resolved
+* by hand or (for example) dev-only plugins would leak into production builds.
+*/
+async function resolveNestedPlugins(plugins, config, environment, nuxt) {
+	const configEnv = resolveConfigEnv(environment, config, nuxt);
+	const resolved = [];
+	for (const plugin of plugins) {
+		const { apply, applyToEnvironment } = plugin;
+		if (apply && (typeof apply === "function" ? !apply(config, configEnv) : apply !== configEnv.command)) continue;
+		const applied = applyToEnvironment ? await applyToEnvironment(environment) : true;
+		if (applied === true) {
+			resolved.push(plugin);
+			continue;
+		}
+		resolved.push(...await flattenPlugins(applied));
+	}
+	return resolved;
+}
+/**
+* `getTopLevelConfig` is only available from Vite 6, and kit is used with older
+* versions of nuxt (and therefore vite), so fall back to what we can infer.
+*/
+function resolveConfigEnv(environment, config, nuxt) {
+	const topLevelConfig = environment.getTopLevelConfig?.() ?? environment.config;
+	return {
+		command: topLevelConfig?.command ?? (nuxt.options.dev ? "serve" : "build"),
+		mode: topLevelConfig?.mode ?? config.mode ?? nuxt.options.vite?.mode ?? (nuxt.options.dev ? "development" : "production")
+	};
+}
+async function flattenPlugins(option) {
+	const resolved = await option;
+	if (!resolved) return [];
+	if (Array.isArray(resolved)) return (await Promise.all(resolved.map(flattenPlugins))).flat();
+	return [resolved];
+}
 function addBuildPlugin(pluginFactory, options) {
 	if (pluginFactory.vite) addVitePlugin(pluginFactory.vite, options);
 	if (pluginFactory.webpack) addWebpackPlugin(pluginFactory.webpack, options);
@@ -1708,7 +1767,8 @@ function addComponentExports(opts) {
 	const nuxt = useNuxt();
 	const components = [];
 	nuxt.hook("components:dirs", async () => {
-		const names = await resolveModuleExportNames(await resolvePath(opts.filePath), { extensions: nuxt.options.extensions });
+		const filePath = await resolvePath(opts.filePath);
+		const names = await resolveModuleExportNames(filePath, { extensions: nuxt.options.extensions });
 		components.length = 0;
 		for (const name of names) components.push(normalizeComponent({
 			name: pascalCase([opts.prefix || "", name === "default" ? "" : name]),
@@ -1806,6 +1866,11 @@ const pageDiagnostics = /* #__PURE__ */ defineDiagnostics({
 			fix: "Use only JSON-serializable values (strings, numbers, booleans, arrays, plain objects) in `defineRouteRules()`.",
 			docs: false
 		},
+		NUXT_B4007: {
+			why: (p) => `\`${p.fnName}\` is called conditionally or used as an expression in \`${p.file}\`, but it is a compiler macro that is extracted at build time and always applies.`,
+			fix: (p) => `Call \`${p.fnName}({ ... })\` once, as a statement at the top level of the \`<script setup>\` block.`,
+			docs: false
+		},
 		NUXT_B4008: {
 			why: "Server pages with `ssr: false` are not supported while component islands are auto-detected.",
 			fix: "Set `experimental.componentIslands` to `true`.",
@@ -1906,10 +1971,11 @@ function resolveRoot(basePkg, from) {
 	if (rootCache.has(cacheKey)) return rootCache.get(cacheKey);
 	const promise = (async () => {
 		try {
-			return dirname(await resolvePackageJSON(resolveModulePath(basePkg, {
+			const r = resolveModulePath(basePkg, {
 				from,
 				...TYPE_RESOLVE_OPTIONS
-			})));
+			});
+			return dirname(await resolvePackageJSON(r));
 		} catch {
 			return;
 		}
@@ -2386,16 +2452,25 @@ async function writeTypes(nuxt) {
 	const sharedDeclarationPath = resolve(nuxt.options.buildDir, "nuxt.shared.d.ts");
 	await promises.mkdir(nuxt.options.buildDir, { recursive: true });
 	await Promise.all([
-		promises.writeFile(appTsConfigPath, JSON.stringify(tsConfig, null, 2)),
-		promises.writeFile(legacyTsConfigPath, JSON.stringify(legacyTsConfig, null, 2)),
-		promises.writeFile(nodeTsConfigPath, JSON.stringify(nodeTsConfig, null, 2)),
-		promises.writeFile(sharedTsConfigPath, JSON.stringify(sharedTsConfig, null, 2)),
-		promises.writeFile(declarationPath, declaration),
-		promises.writeFile(nodeDeclarationPath, nodeDeclaration),
-		promises.writeFile(sharedDeclarationPath, sharedDeclaration)
+		writeIfChanged(appTsConfigPath, JSON.stringify(tsConfig, null, 2)),
+		writeIfChanged(legacyTsConfigPath, JSON.stringify(legacyTsConfig, null, 2)),
+		writeIfChanged(nodeTsConfigPath, JSON.stringify(nodeTsConfig, null, 2)),
+		writeIfChanged(sharedTsConfigPath, JSON.stringify(sharedTsConfig, null, 2)),
+		writeIfChanged(declarationPath, declaration),
+		writeIfChanged(nodeDeclarationPath, nodeDeclaration),
+		writeIfChanged(sharedDeclarationPath, sharedDeclaration)
 	]);
 }
 /**
+* Types are regenerated on every start and are usually identical, so avoid
+* touching the files: an unchanged mtime keeps editors and `tsc --watch` from
+* redoing work they have already done.
+*/
+async function writeIfChanged(path, contents) {
+	if (await promises.readFile(path, "utf8").catch(() => void 0) === contents) return;
+	await promises.writeFile(path, contents);
+}
+/**
 * Sort the paths in the tsconfig.json file, so
 * - Hoisted package paths stay at the top (`typescript.hoist`)
 * - Custom layer aliases follow, then generic `#layers/*` aliases
@@ -2627,6 +2702,127 @@ function addPluginTemplate(plugin, opts = {}) {
 	}, opts);
 }
 //#endregion
+//#region src/watch.ts
+const RECHECK_DELAY = 70;
+/**
+* A single write moves the mtime more than once (truncate, then write) and
+* chokidar may dispatch `change` off the first of those, so a mtime a hair
+* newer than the one recorded is the tail of a write that *was* reported
+* rather than one that was dropped.
+*/
+const MTIME_EPSILON = 10;
+const RECOVERY_FLAG = Symbol.for("nuxt:watch-recovery");
+/**
+* chokidar suppresses a `change` event that lands within 50ms of the previous
+* `change` for the same path, and never replays it. A save that follows a fast
+* HMR round trip is therefore silently lost until the file is touched again,
+* which looks exactly like broken HMR. This is true of every chokidar major
+* Nuxt uses.
+*
+* Raw fs events are not throttled, so once chokidar has reported a file at
+* least once we can use them to notice a modification that never surfaced as a
+* `change` event, and re-emit it after the throttle window has passed.
+*
+* @param watcher the chokidar watcher to patch
+* @returns a disposer releasing the recovery state; call it when the watcher closes
+*/
+function recoverThrottledChanges(watcher) {
+	if (watcher[RECOVERY_FLAG]) return () => {};
+	Object.defineProperty(watcher, RECOVERY_FLAG, {
+		value: true,
+		configurable: true
+	});
+	const tracked = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	let disposed = false;
+	/**
+	* With `cwd` set, chokidar emits high-level events relative to it while raw
+	* events carry an absolute `watchedPath`, so everything is keyed absolutely
+	* and the emitted path is kept alongside to re-emit in chokidar's namespace.
+	*/
+	const cwd = watcher.options?.cwd;
+	const toKey = (path) => cwd ? resolve$1(cwd, path) : path;
+	/**
+	* `watchedPath` is the (possibly relative) path chokidar handed to `fs.watch`
+	* and `path` is the name `fs.watch` reported, which is a basename both when
+	* the file itself is watched and when its parent directory is. The two are
+	* indistinguishable for a directory containing a child of the same name, so
+	* pick whichever candidate chokidar has already reported a modification time
+	* for, and use native separators to match the paths chokidar emits.
+	*/
+	const resolveTracked = (path, details) => {
+		const watched = typeof details?.watchedPath === "string" ? details.watchedPath : void 0;
+		if (!watched) {
+			const key = toKey(path);
+			return tracked.has(key) ? key : void 0;
+		}
+		const child = toKey(join$1(watched, path));
+		if (tracked.has(child)) return child;
+		const parent = toKey(watched);
+		return tracked.has(parent) ? parent : void 0;
+	};
+	const track = (path, stats) => {
+		if (disposed) return;
+		const key = toKey(path);
+		if (stats) {
+			tracked.set(key, {
+				mtimeMs: stats.mtimeMs,
+				path
+			});
+			return;
+		}
+		stat(key).then((s) => {
+			if (!disposed) tracked.set(key, {
+				mtimeMs: s.mtimeMs,
+				path
+			});
+		}, () => {});
+	};
+	const forget = (path) => {
+		const key = toKey(path);
+		tracked.delete(key);
+		const timeout = pending.get(key);
+		if (timeout) {
+			clearTimeout(timeout);
+			pending.delete(key);
+		}
+	};
+	watcher.on("add", track);
+	watcher.on("change", track);
+	watcher.on("unlink", forget);
+	watcher.on("raw", (event, path, details) => {
+		if (disposed) return;
+		if (event !== "change" && event !== "rename" && event !== "modified") return;
+		if (typeof path !== "string" || !path) return;
+		const file = resolveTracked(path, details);
+		if (!file || pending.has(file)) return;
+		const timeout = setTimeout(() => {
+			pending.delete(file);
+			if (disposed) return;
+			stat(file).then((stats) => {
+				if (disposed) return;
+				const previous = tracked.get(file);
+				if (!previous) return;
+				tracked.set(file, {
+					mtimeMs: stats.mtimeMs,
+					path: previous.path
+				});
+				if (stats.mtimeMs - previous.mtimeMs <= MTIME_EPSILON) return;
+				watcher.emit("change", previous.path, stats);
+				watcher.emit("all", "change", previous.path, stats);
+			}, () => {});
+		}, RECHECK_DELAY);
+		timeout.unref();
+		pending.set(file, timeout);
+	});
+	return () => {
+		disposed = true;
+		for (const timeout of pending.values()) clearTimeout(timeout);
+		pending.clear();
+		tracked.clear();
+	};
+}
+//#endregion
 //#region src/diagnostics/build.ts
 /**
 * B1xxx
@@ -2941,8 +3137,18 @@ const bundlerDiagnostics = /* #__PURE__ */ defineDiagnostics({
 			why: "The server webpack build does not externalize dependencies.",
 			fix: "Externalize dependencies in the server build (`externals`) for better build performance.",
 			docs: false
+		},
+		NUXT_B7020: {
+			why: "The client build manifest is disabled, but Nuxt requires it to render the correct assets for each route.",
+			fix: "Remove any `build.manifest: false` override from your `nuxt.config` `vite` options or from a Vite plugin `config`/`configEnvironment` hook.",
+			docs: false
+		},
+		NUXT_B7021: {
+			why: (p) => `The client build manifest was expected at \`${p.manifestFile}\` but was not emitted by the client build.`,
+			fix: "Check that no Vite plugin removes or renames the client build manifest in a `generateBundle`/`writeBundle` hook. If this happens with no such plugin, please report it at https://github.com/nuxt/nuxt/issues.",
+			docs: false
 		}
 	}
 });
 //#endregion
-export { DEFAULT_JSX_FILE_EXTENSIONS, DEFAULT_JS_FILE_EXTENSIONS, addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildDiagnostics, buildNuxt, bundlerDiagnostics, checkNuxtCompatibility, componentDiagnostics, configDiagnostics, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getLayerDirectories, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, headDiagnostics, importModule, installModule, installModules, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, packageName, pageDiagnostics, pluginDiagnostics, requireModule, resolveAlias, resolveDeclarationPath, resolveFiles, resolveIgnorePatterns, resolveModule, resolveModuleWithOptions, resolveNuxtModule, resolvePath, resolveTypePaths, runWithNuxtContext, setBuildOutput, setGlobalHead, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateAppConfig, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
+export { DEFAULT_JSX_FILE_EXTENSIONS, DEFAULT_JS_FILE_EXTENSIONS, addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildDiagnostics, buildNuxt, bundlerDiagnostics, checkNuxtCompatibility, componentDiagnostics, configDiagnostics, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getLayerDirectories, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, headDiagnostics, importModule, installModule, installModules, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, packageName, pageDiagnostics, pluginDiagnostics, recoverThrottledChanges, requireModule, resolveAlias, resolveDeclarationPath, resolveFiles, resolveIgnorePatterns, resolveModule, resolveModuleWithOptions, resolveNuxtModule, resolvePath, resolveTypePaths, runWithNuxtContext, setBuildOutput, setGlobalHead, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateAppConfig, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/nuxt__kit",
-  "version": "4.5.1-depup.0",
+  "version": "4.5.2-depup.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -25,8 +25,8 @@
     "consola": "^3.4.2",
     "defu": "^6.1.7",
     "destr": "^2.0.5",
-    "errx": "^0.1.0",
-    "exsolve": "^1.1.0",
+    "errx": "^0.1.2",
+    "exsolve": "^1.1.1",
     "ignore": "^7.0.6",
     "jiti": "^2.7.0",
     "klona": "^2.0.6",
@@ -41,17 +41,18 @@
     "ufo": "^1.6.4",
     "unctx": "^3.0.0",
     "untyped": "^2.0.0",
-    "verkit": "^0.3.1"
+    "verkit": "^0.3.2"
   },
   "devDependencies": {
+    "chokidar": "^5.0.0",
     "hookable": "^6.1.1",
     "nitropack": "2.13.4",
-    "tsdown": "0.22.0",
-    "unimport": "^6.3.1",
-    "vite": "^8.1.5",
+    "tsdown": "0.22.14",
+    "unimport": "^6.4.0",
+    "vite": "^8.2.0",
     "vitest": "4.1.10",
-    "webpack": "^5.108.4",
-    "@nuxt/schema": "4.5.1"
+    "webpack": "^5.109.2",
+    "@nuxt/schema": "4.5.2"
   },
   "engines": {
     "node": ">=18.12.0"
@@ -75,14 +76,14 @@
         "to": "^4.0.0-beta.5"
       },
       "verkit": {
-        "from": "^0.2.0",
-        "to": "^0.3.1"
+        "from": "^0.3.1",
+        "to": "^0.3.2"
       }
     },
     "depsUpdated": 2,
     "originalPackage": "@nuxt/kit",
-    "originalVersion": "4.5.1",
-    "processedAt": "2026-07-27T16:44:14.139Z",
+    "originalVersion": "4.5.2",
+    "processedAt": "2026-08-05T16:35:04.236Z",
     "smokeTest": "passed"
   }
 }