@depup/nuxt 4.3.0-depup.0 → 4.4.2-depup.1

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import process from 'node:process';
 import fs, { statSync, promises, existsSync, readdirSync, mkdirSync, writeFileSync } from 'node:fs';
-import { mkdir, readFile, readdir, writeFile, rm, stat, unlink, open } from 'node:fs/promises';
+import { mkdir, readFile, readdir, writeFile, stat, unlink, open, rm } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { dirname, resolve, normalize, basename, extname, relative, isAbsolute, join, parse as parse$1 } from 'pathe';
+import { dirname, resolve, normalize, basename, extname, relative, join, isAbsolute, parse as parse$1 } from 'pathe';
 import { createHooks, createDebugger } from 'hookable';
 import ignore from 'ignore';
-import { useLogger, tryUseNuxt, useNuxt, directoryToURL, getLayerDirectories, resolveFiles, resolvePath, defineNuxtModule, findPath, addPlugin, addTemplate, addTypeTemplate, addComponent, useNitro, addBuildPlugin, isIgnored, resolveAlias as resolveAlias$1, addPluginTemplate, addImportsSources, addVitePlugin, createIsIgnored, updateTemplates, tryResolveModule, normalizeModuleTranspilePath, importModule, createResolver, runWithNuxtContext, nuxtCtx, loadNuxtConfig, installModules, resolveIgnorePatterns, addRouteMiddleware, resolveModuleWithOptions, normalizeTemplate, normalizePlugin } from '@nuxt/kit';
+import { useLogger, tryUseNuxt, useNuxt, directoryToURL, getLayerDirectories, resolveFiles, resolvePath, defineNuxtModule, findPath, addPlugin, addTemplate, addTypeTemplate, addComponent, isIgnored, useNitro, addBuildPlugin, resolveAlias as resolveAlias$1, addPluginTemplate, addImportsSources, addVitePlugin, createIsIgnored, updateTemplates, tryResolveModule, normalizeModuleTranspilePath, importModule, createResolver, runWithNuxtContext, nuxtCtx, loadNuxtConfig, installModules, resolveIgnorePatterns, addRouteMiddleware, resolveModuleWithOptions, normalizeTemplate, normalizePlugin } from '@nuxt/kit';
 import { resolvePackageJSON, readPackage, readPackageJSON } from 'pkg-types';
 import { hash, isEqual, serialize } from 'ohash';
 import { consola } from 'consola';
@@ -14,24 +14,25 @@ import onChange from 'on-change';
 import { colors } from 'consola/utils';
 import { resolveCompatibilityDatesFromEnv, formatDate } from 'compatx';
 import escapeRE from 'escape-string-regexp';
-import { withTrailingSlash as withTrailingSlash$1, parseURL, parseQuery, joinURL, withLeadingSlash, withoutLeadingSlash } from 'ufo';
+import { withTrailingSlash as withTrailingSlash$1, joinURL, withoutLeadingSlash } from 'ufo';
 import { ImpoundPlugin } from 'impound';
 import { defu } from 'defu';
 import { satisfies, coerce } from 'semver';
 import { isCI, provider, hasTTY } from 'std-env';
-import { genArrayFromRaw, genSafeVariableName, genImport, genDynamicImport, genObjectFromRawEntries, genString, genDynamicTypeImport, genExport } from 'knitwork';
+import { genArrayFromRaw, genSafeVariableName, genImport, genDynamicImport, genObjectFromRawEntries, genString, genObjectKey, genInlineTypeImport, genDynamicTypeImport, genExport } from 'knitwork';
 import { resolveModulePath } from 'exsolve';
 import { addDependency } from 'nypm';
 import { reverseResolveAlias, filename, resolveAlias } from 'pathe/utils';
-import { createRoutesContext } from 'unplugin-vue-router';
-import { resolveOptions } from 'unplugin-vue-router/options';
+import { createRoutesContext, resolveOptions } from 'vue-router/unplugin';
 import { createRouter, addRoute, findAllRoutes } from 'rou3';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
+import picomatch from 'picomatch';
 import { runInNewContext } from 'node:vm';
 import { klona } from 'klona';
 import { parseAndWalk, ScopeTracker, walk, isBindingIdentifier, getUndeclaredIdentifiersInFunction } from 'oxc-walker';
 import { parseSync } from 'oxc-parser';
 import { transformSync } from 'oxc-transform';
+import { compileParsePath, buildTree, removeFile, addFile, toVueRouter4 } from 'unrouting';
 import { splitByCase, kebabCase, pascalCase, camelCase } from 'scule';
 import { createUnplugin } from 'unplugin';
 import { findStaticImports, findExports, parseStaticImport, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
@@ -41,17 +42,16 @@ import { defineUnimportPreset, createUnimport, toExports, toTypeDeclarationFile,
 import { glob } from 'tinyglobby';
 import { parse, walk as walk$1, ELEMENT_NODE } from 'ultrahtml';
 import { isObject } from '@vue/shared';
-import { parseQuery as parseQuery$1 } from 'vue-router';
+import { resolve as resolve$1 } from 'node:path';
+import { parseTar, createTar } from 'nanotar';
 import { createTransformer } from 'unctx/transform';
+import { performance } from 'node:perf_hooks';
 import { watch as watch$1 } from 'chokidar';
 import { debounce } from 'perfect-debounce';
 import { resolveSchema, generateTypes } from 'untyped';
 import untypedPlugin from 'untyped/babel-plugin';
 import { createJiti } from 'jiti';
 import { minifySync } from 'oxc-minify';
-import { performance } from 'node:perf_hooks';
-import { resolve as resolve$1 } from 'node:path';
-import { parseTar, createTar } from 'nanotar';
 
 function toArray(value) {
   return Array.isArray(value) ? value : [value];
@@ -66,6 +66,10 @@ function isDirectorySync(path) {
     return false;
   }
 }
+const LEADING_DOT_RE = /^\.+/g;
+function normalizeExtension(input) {
+  return input.replace(LEADING_DOT_RE, "");
+}
 function stripExtension(path) {
   return path.replace(/\.[^./\\]+$/, "");
 }
@@ -73,6 +77,10 @@ function isWhitespace(char) {
   const c = typeof char === "string" ? char.charCodeAt(0) : char;
   return c === 32 || c === 9 || c === 10 || c === 13 || c === 12;
 }
+const JS_EXT_RE = /^[^?]*\.(?:[jt]sx?|[cm][jt]s)(?:$|\?)/;
+const NUXT_LIB_RE = /^[^?]*node_modules\/(?:nuxt|nuxt3|nuxt-nightly|@nuxt)\//;
+const STYLE_QUERY_RE$1 = /[?&]type=style/;
+const MACRO_QUERY_RE$2 = /[?&]macro(?:=|&|$)/;
 const DECLARATION_EXTENSIONS = ["d.ts", "d.mts", "d.cts", "d.vue.ts", "d.vue.mts", "d.vue.cts"];
 const logger = useLogger("nuxt");
 function resolveToAlias(path, nuxt = tryUseNuxt()) {
@@ -192,34 +200,51 @@ function resolveComponentNameSegments(fileName, prefixParts) {
   return [...componentNameParts, ...fileNameParts];
 }
 
+function parseModuleId(id) {
+  const qIndex = id.indexOf("?");
+  if (qIndex === -1) {
+    return { pathname: id, search: "" };
+  }
+  return { pathname: id.slice(0, qIndex), search: id.slice(qIndex) };
+}
+const NUXT_COMPONENT_RE = /[?&]nuxt_component=/;
+const MACRO_RE$1 = /[?&]macro=/;
+const VUE_QUERY_RE = /[?&]vue(?:&|$)/;
+const SETUP_QUERY_RE = /[?&]setup(?:=|&|$)/;
+const TYPE_QUERY_RE = /[?&]type=([^&]*)/;
 function isVue(id, opts = {}) {
-  const { search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+  const { search } = parseModuleId(id);
   if (id.endsWith(".vue") && !search) {
     return true;
   }
   if (!search) {
     return false;
   }
-  const query = parseQuery(search);
-  if (query.nuxt_component) {
+  if (NUXT_COMPONENT_RE.test(search)) {
     return false;
   }
-  if (query.macro && (search === "?macro=true" || !opts.type || opts.type.includes("script"))) {
+  if (MACRO_RE$1.test(search) && (search === "?macro=true" || !opts.type || opts.type.includes("script"))) {
     return true;
   }
-  const type = "setup" in query ? "script" : query.type;
-  if (!("vue" in query) || opts.type && !opts.type.includes(type)) {
+  if (!VUE_QUERY_RE.test(search)) {
     return false;
   }
+  if (opts.type) {
+    const type = SETUP_QUERY_RE.test(search) ? "script" : TYPE_QUERY_RE.exec(search)?.[1];
+    if (!type || !opts.type.includes(type)) {
+      return false;
+    }
+  }
   return true;
 }
 const JS_RE$1 = /\.(?:[cm]?j|t)sx?$/;
+const VUE_ID_RE = /\.vue(?:\?|$)/;
 function isJS(id) {
-  const { pathname } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+  const { pathname } = parseModuleId(id);
   return JS_RE$1.test(pathname);
 }
 function getLoader(id) {
-  const { pathname } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+  const { pathname } = parseModuleId(id);
   const ext = extname(pathname);
   if (ext === ".vue") {
     return "vue";
@@ -249,30 +274,69 @@ const QUOTE_RE = /["']/g;
 const EXTENSION_RE = /\b\.\w+$/g;
 const SX_RE = /\.[tj]sx$/;
 
-const SegmentTokenType = {
-  static: "static",
-  dynamic: "dynamic",
-  optional: "optional",
-  catchall: "catchall",
-  group: "group"
-};
-const SegmentParserState = {
-  initial: "initial",
-  ...SegmentTokenType
-};
-const enUSComparator = new Intl.Collator("en-US");
-async function resolvePagesRoutes(pattern, nuxt = useNuxt()) {
+function createPagesContext(options = {}) {
+  const modes = options.shouldUseServerComponents ? ["server", "client"] : ["client"];
+  const treeOptions = {
+    roots: options.roots,
+    modes,
+    warn: (msg) => logger.warn(msg)
+  };
+  const emitOptions = {
+    onDuplicateRouteName: (_name, file, existingFile) => {
+      logger.warn(`Route name generated for \`${file}\` is the same as \`${existingFile}\`. You may wish to set a custom name using \`definePageMeta\` within the page file.`);
+    },
+    attrs: { mode: modes }
+  };
+  const compiledParse = compileParsePath(treeOptions);
+  let tree = buildTree([], treeOptions);
+  const trackedFiles = /* @__PURE__ */ new Set();
+  return {
+    emit() {
+      return toVueRouter4(tree, emitOptions);
+    },
+    addFile(filePath, priority = 0) {
+      addFile(tree, { path: filePath, priority }, compiledParse);
+      trackedFiles.add(filePath);
+    },
+    removeFile(filePath) {
+      const removed = removeFile(tree, filePath);
+      if (removed) {
+        trackedFiles.delete(filePath);
+      }
+      return removed;
+    },
+    rebuild(files) {
+      tree = buildTree(files, treeOptions);
+      trackedFiles.clear();
+      for (const f of files) {
+        trackedFiles.add(f.path);
+      }
+    },
+    trackedFiles
+  };
+}
+async function resolvePagesRoutes(pattern, nuxt = useNuxt(), ctx) {
   const pagesDirs = getLayerDirectories(nuxt).map((d) => d.appPages);
-  const scannedFiles = [];
-  for (const dir of pagesDirs) {
+  const inputFiles = [];
+  for (let priority = 0; priority < pagesDirs.length; priority++) {
+    const dir = pagesDirs[priority];
     const files = await resolveFiles(dir, pattern);
-    scannedFiles.push(...files.map((file) => ({ relativePath: relative(dir, file), absolutePath: file })));
+    for (const file of files) {
+      inputFiles.push({ path: file, priority });
+    }
   }
-  scannedFiles.sort((a, b) => enUSComparator.compare(a.relativePath, b.relativePath));
-  const allRoutes = generateRoutesFromFiles(uniqueBy(scannedFiles, "relativePath"), {
-    shouldUseServerComponents: !!nuxt.options.experimental.componentIslands
-  });
-  const pages = uniqueBy(allRoutes, "path");
+  let pages;
+  if (ctx) {
+    ctx.rebuild(inputFiles);
+    pages = ctx.emit();
+  } else {
+    const oneShot = createPagesContext({ roots: pagesDirs, shouldUseServerComponents: !!nuxt.options.experimental.componentIslands });
+    oneShot.rebuild(inputFiles);
+    pages = oneShot.emit();
+  }
+  return augmentAndResolve(pages, ctx?.trackedFiles ?? new Set(inputFiles.map((f) => f.path)), nuxt);
+}
+async function augmentAndResolve(pages, trackedFiles, nuxt = useNuxt()) {
   const shouldAugment = nuxt.options.experimental.scanPageMeta || nuxt.options.experimental.typedPages;
   if (shouldAugment === false) {
     await nuxt.callHook("pages:extend", pages);
@@ -284,7 +348,7 @@ async function resolvePagesRoutes(pattern, nuxt = useNuxt()) {
       "middleware",
       ...extraPageMetaExtractionKeys
     ]),
-    fullyResolvedPaths: new Set(scannedFiles.map((file) => file.absolutePath))
+    fullyResolvedPaths: trackedFiles
   };
   if (shouldAugment === "after-resolve") {
     await nuxt.callHook("pages:extend", pages);
@@ -298,68 +362,11 @@ async function resolvePagesRoutes(pattern, nuxt = useNuxt()) {
   await nuxt.callHook("pages:resolved", pages);
   return pages;
 }
-const INDEX_PAGE_RE = /\/index$/;
-function generateRoutesFromFiles(files, options = {}) {
-  if (!files.length) {
-    return [];
-  }
-  const routes = [];
-  const sortedFiles = [...files].sort((a, b) => a.relativePath.length - b.relativePath.length);
-  for (const file of sortedFiles) {
-    const segments = file.relativePath.replace(new RegExp(`${escapeRE(extname(file.relativePath))}$`), "").split("/");
-    const route = {
-      name: "",
-      path: "",
-      file: file.absolutePath,
-      children: []
-    };
-    let parent = routes;
-    const routeGroups = [];
-    const lastSegment = segments[segments.length - 1];
-    if (lastSegment.endsWith(".server")) {
-      segments[segments.length - 1] = lastSegment.replace(".server", "");
-      if (options.shouldUseServerComponents) {
-        route.mode = "server";
-      }
-    } else if (lastSegment.endsWith(".client")) {
-      segments[segments.length - 1] = lastSegment.replace(".client", "");
-      route.mode = "client";
-    }
-    for (let i = 0; i < segments.length; i++) {
-      const segment = segments[i];
-      const tokens = parseSegment(segment, file.absolutePath);
-      if (tokens.every((token) => token.type === SegmentTokenType.group)) {
-        const groupNames = tokens.map((t) => t.value);
-        routeGroups.push(...groupNames);
-        continue;
-      }
-      const segmentName = tokens.map(({ value, type }) => type === SegmentTokenType.group ? "" : value).join("");
-      route.name += (route.name && "/") + segmentName;
-      const routePath = getRoutePath(tokens, segments[i + 1] !== void 0 && segments[i + 1] !== "index");
-      const path = withLeadingSlash(joinURL(route.path, routePath.replace(INDEX_PAGE_RE, "/")));
-      const child = parent.find((parentRoute) => parentRoute.name === route.name && parentRoute.path === path.replace("([^/]*)*", "(.*)*"));
-      if (child && child.children) {
-        parent = child.children;
-        route.path = "";
-      } else if (segmentName === "index" && !route.path) {
-        route.path += "/";
-      } else if (segmentName !== "index") {
-        route.path += routePath;
-      }
-    }
-    if (routeGroups.length > 0) {
-      route.meta ||= {};
-      route.meta.groups = routeGroups;
-    }
-    parent.push(route);
-  }
-  return prepareRoutes(routes);
-}
 async function augmentPages(routes, vfs, ctx = {}) {
   ctx.augmentedPages ??= /* @__PURE__ */ new Set();
   for (const route of routes) {
     if (route.file && !ctx.pagesToSkip?.has(route.file)) {
-      const fileContent = route.file in vfs ? vfs[route.file] : fs.readFileSync(ctx.fullyResolvedPaths?.has(route.file) ? route.file : await resolvePath(route.file), "utf-8");
+      const fileContent = vfs[route.file] ?? fs.readFileSync(ctx.fullyResolvedPaths?.has(route.file) ? route.file : await resolvePath(route.file), "utf-8");
       const routeMeta = getRouteMeta(fileContent, route.file, ctx.extraExtractionKeys);
       if (route.meta) {
         routeMeta.meta = defu({}, routeMeta.meta, route.meta);
@@ -376,7 +383,7 @@ async function augmentPages(routes, vfs, ctx = {}) {
   }
   return ctx.augmentedPages;
 }
-const SFC_SCRIPT_RE = /<script(?<attrs>[^>]*)>(?<content>[\s\S]*?)<\/script[^>]*>/gi;
+const SFC_SCRIPT_RE = /<script(?=\s|>)(?<attrs>[^>]*)>(?<content>[\s\S]*?)<\/script\s*>/gi;
 function extractScriptContent(sfc) {
   const contents = [];
   for (const match of sfc.matchAll(SFC_SCRIPT_RE)) {
@@ -497,153 +504,35 @@ function getRouteMeta(contents, absolutePath, extraExtractionKeys = /* @__PURE__
   extractCache[absolutePath] = extractedData;
   return klona(extractedData);
 }
-const ESCAPE_CHARS_RE = /[\\:]/g;
-function getRoutePath(tokens, hasSucceedingSegment = false) {
-  return tokens.reduce((path, token) => {
-    switch (token.type) {
-      case SegmentTokenType.optional:
-        return path + `:${token.value}?`;
-      case SegmentTokenType.dynamic:
-        return path + `:${token.value}()`;
-      case SegmentTokenType.catchall:
-        return path + (hasSucceedingSegment ? `:${token.value}([^/]*)*` : `:${token.value}(.*)*`);
-      case SegmentTokenType.group:
-        return path;
-      case SegmentTokenType.static:
-      default:
-        return path + token.value.replace(ESCAPE_CHARS_RE, "\\$&");
-    }
-  }, "/");
-}
-const PARAM_CHAR_RE = /[\w.]/;
-function parseSegment(segment, absolutePath) {
-  let state = SegmentParserState.initial;
-  let i = 0;
-  let buffer = "";
-  const tokens = [];
-  function consumeBuffer() {
-    if (!buffer) {
-      return;
-    }
-    if (state === SegmentParserState.initial) {
-      throw new Error("wrong state");
-    }
-    tokens.push({ type: state, value: buffer });
-    buffer = "";
-  }
-  while (i < segment.length) {
-    const c = segment[i];
-    switch (state) {
-      case SegmentParserState.initial:
-        buffer = "";
-        if (c === "[") {
-          state = SegmentParserState.dynamic;
-        } else if (c === "(") {
-          state = SegmentParserState.group;
-        } else {
-          i--;
-          state = SegmentParserState.static;
-        }
-        break;
-      case SegmentParserState.static:
-        if (c === "[") {
-          consumeBuffer();
-          state = SegmentParserState.dynamic;
-        } else if (c === "(") {
-          consumeBuffer();
-          state = SegmentParserState.group;
-        } else {
-          buffer += c;
-        }
-        break;
-      case SegmentParserState.catchall:
-      case SegmentParserState.dynamic:
-      case SegmentParserState.optional:
-      case SegmentParserState.group:
-        if (buffer === "...") {
-          buffer = "";
-          state = SegmentParserState.catchall;
-        }
-        if (c === "[" && state === SegmentParserState.dynamic) {
-          state = SegmentParserState.optional;
-        }
-        if (c === "]" && (state !== SegmentParserState.optional || segment[i - 1] === "]")) {
-          if (!buffer) {
-            throw new Error("Empty param");
-          } else {
-            consumeBuffer();
-          }
-          state = SegmentParserState.initial;
-        } else if (c === ")" && state === SegmentParserState.group) {
-          if (!buffer) {
-            throw new Error("Empty group");
-          } else {
-            consumeBuffer();
-          }
-          state = SegmentParserState.initial;
-        } else if (c && PARAM_CHAR_RE.test(c)) {
-          buffer += c;
-        } else if (state === SegmentParserState.dynamic || state === SegmentParserState.optional) {
-          if (c !== "[" && c !== "]") {
-            logger.warn(`'\`${c}\`' is not allowed in a dynamic route parameter and has been ignored. Consider renaming \`${absolutePath}\`.`);
-          }
-        }
-        break;
-    }
-    i++;
-  }
-  if (state === SegmentParserState.dynamic) {
-    throw new Error(`Unfinished param "${buffer}"`);
+function serializeRouteValue(value, skipSerialisation = false) {
+  if (skipSerialisation || value === void 0) {
+    return void 0;
   }
-  consumeBuffer();
-  return tokens;
+  return JSON.stringify(value);
 }
-function findRouteByName(name, routes) {
-  for (const route of routes) {
-    if (route.name === name) {
-      return route;
-    }
-    if (route.children && route.children.length > 0) {
-      const child = findRouteByName(name, route.children);
-      if (child) {
-        return child;
-      }
-    }
+function normalizeComponent(page, pageImport, routeName) {
+  if (page.mode === "server") {
+    return `() => createIslandPage(${routeName})`;
   }
-}
-const NESTED_PAGE_RE = /\//g;
-function prepareRoutes(routes, parent, names = /* @__PURE__ */ new Set()) {
-  for (const route of routes) {
-    if (route.name) {
-      route.name = route.name.replace(INDEX_PAGE_RE, "").replace(NESTED_PAGE_RE, "-");
-      if (names.has(route.name)) {
-        const existingRoute = findRouteByName(route.name, routes);
-        const extra = existingRoute?.name ? `is the same as \`${existingRoute.file}\`` : "is a duplicate";
-        logger.warn(`Route name generated for \`${route.file}\` ${extra}. You may wish to set a custom name using \`definePageMeta\` within the page file.`);
-      }
-    }
-    if (parent && route.path[0] === "/") {
-      route.path = route.path.slice(1);
-    }
-    if (route.children?.length) {
-      route.children = prepareRoutes(route.children, route, names);
-    }
-    if (route.children?.find((childRoute) => childRoute.path === "")) {
-      delete route.name;
-    }
-    if (route.name) {
-      names.add(route.name);
-    }
+  if (page.mode === "client") {
+    return `() => createClientPage(${pageImport})`;
   }
-  return routes;
+  return pageImport;
 }
-function serializeRouteValue(value, skipSerialisation = false) {
-  if (skipSerialisation || value === void 0) {
-    return void 0;
+function normalizeComponentWithName(page, isSyncImport, pageImportName, pageImport, routeName, metaRouteName) {
+  if (isSyncImport) {
+    return `Object.assign(${pageImportName}, { __name: ${metaRouteName} })`;
   }
-  return JSON.stringify(value);
+  if (page.mode === "server") {
+    return `() => createIslandPage(${routeName})`;
+  }
+  if (page.mode === "client") {
+    return `() => createClientPage(${pageImport}).then((c) => Object.assign(c, { __name: ${metaRouteName} }))`;
+  }
+  return `${pageImport}.then((m) => Object.assign(m.default, { __name: ${metaRouteName} }))`;
 }
 function normalizeRoutes(routes, metaImports = /* @__PURE__ */ new Set(), options) {
+  const nuxt = useNuxt();
   return {
     imports: metaImports,
     routes: genArrayFromRaw(routes.map((page) => {
@@ -683,15 +572,18 @@ function normalizeRoutes(routes, metaImports = /* @__PURE__ */ new Set(), option
       if (page._sync) {
         metaImports.add(genImport(file, [{ name: "default", as: pageImportName }]));
       }
-      const pageImport = page._sync && page.mode !== "client" ? pageImportName : genDynamicImport(file);
+      const isSyncImport = page._sync && page.mode !== "client";
+      const pageImport = isSyncImport ? pageImportName : genDynamicImport(file);
+      const metaRouteName = `${metaImportName}?.name ?? ${route.name}`;
+      const component = nuxt.options.experimental.normalizePageNames ? normalizeComponentWithName(page, isSyncImport, pageImportName, pageImport, route.name, metaRouteName) : normalizeComponent(page, pageImport, route.name);
       const metaRoute = {
-        name: `${metaImportName}?.name ?? ${route.name}`,
+        name: metaRouteName,
         path: `${metaImportName}?.path ?? ${route.path}`,
         props: `${metaImportName}?.props ?? ${route.props ?? false}`,
         meta: `${metaImportName} || {}`,
         alias: `${metaImportName}?.alias || []`,
         redirect: `${metaImportName}?.redirect`,
-        component: page.mode === "server" ? `() => createIslandPage(${route.name})` : page.mode === "client" ? `() => createClientPage(${pageImport})` : pageImport
+        component
       };
       if (page.mode === "server") {
         metaImports.add(`
@@ -866,12 +758,10 @@ const PageMetaPlugin = (options = {}) => createUnplugin(() => {
   return {
     name: "nuxt:pages-macros-transform",
     enforce: "post",
-    transformInclude(id) {
-      return !!parseMacroQuery(id).macro;
-    },
     transform: {
       filter: {
         id: {
+          include: /[?&]macro=true\b/,
           exclude: [/(?:\?|%3F).*type=(?:style|template)/]
         },
         code: {
@@ -919,7 +809,7 @@ const PageMetaPlugin = (options = {}) => createUnplugin(() => {
         if (!hasMacro && !code.includes("export { default }") && !code.includes("__nuxt_page_meta")) {
           if (!code) {
             s.append(options.dev ? CODE_DEV_EMPTY + CODE_HMR : CODE_EMPTY);
-            const { pathname } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+            const { pathname } = parseModuleId(id);
             logger.error(`The file \`${pathname}\` is not a valid page as it has no content.`);
           } else {
             s.overwrite(0, code.length, options.dev ? CODE_DEV_EMPTY + CODE_HMR : CODE_EMPTY);
@@ -1033,21 +923,46 @@ const PageMetaPlugin = (options = {}) => createUnplugin(() => {
             const metaCode = code.slice(meta.start, meta.end);
             const m = new MagicString(metaCode);
             if (meta.type === "ObjectExpression") {
+              const omitProp = (prop, i) => {
+                const nextProperty = meta.properties[i + 1];
+                if (nextProperty) {
+                  m.overwrite(prop.start - meta.start, nextProperty.start - meta.start, "");
+                } else if (code[prop.end] === ",") {
+                  m.overwrite(prop.start - meta.start, prop.end - meta.start + 1, "");
+                } else {
+                  m.overwrite(prop.start - meta.start, prop.end - meta.start, "");
+                }
+              };
               for (let i = 0; i < meta.properties.length; i++) {
                 const prop = meta.properties[i];
-                if (prop.type === "Property" && prop.key.type === "Identifier" && options.extractedKeys?.includes(prop.key.name)) {
+                if (prop.type !== "Property" || prop.key.type !== "Identifier") {
+                  continue;
+                }
+                if (options.extractedKeys?.includes(prop.key.name)) {
                   const { serializable } = isSerializable(metaCode, prop.value);
-                  if (!serializable) {
-                    continue;
+                  if (serializable) {
+                    omitProp(prop, i);
                   }
-                  const nextProperty = meta.properties[i + 1];
-                  if (nextProperty) {
-                    m.overwrite(prop.start - meta.start, nextProperty.start - meta.start, "");
-                  } else if (code[prop.end] === ",") {
-                    m.overwrite(prop.start - meta.start, prop.end - meta.start + 1, "");
-                  } else {
-                    m.overwrite(prop.start - meta.start, prop.end - meta.start, "");
+                } else if (prop.key.name === "layout" && prop.value.type === "ObjectExpression") {
+                  for (const layoutProp of prop.value.properties) {
+                    if (layoutProp.type !== "Property" || layoutProp.key.type !== "Identifier") {
+                      continue;
+                    }
+                    if (layoutProp.key.name === "name") {
+                      m.appendLeft(
+                        prop.start - meta.start,
+                        `layout: ${code.slice(layoutProp.value.start, layoutProp.value.end)},
+`
+                      );
+                    } else if (layoutProp.key.name === "props") {
+                      m.appendLeft(
+                        prop.start - meta.start,
+                        `layoutProps: ${code.slice(layoutProp.value.start, layoutProp.value.end)},
+`
+                      );
+                    }
                   }
+                  omitProp(prop, i);
                 }
               }
             }
@@ -1114,11 +1029,17 @@ const MACRO_RE = /&macro=true/;
 function rewriteQuery(id) {
   return id.replace(/\?.+$/, (r) => "?macro=true&" + r.replace(QUERY_START_RE, "").replace(MACRO_RE, ""));
 }
+const MACRO_QUERY_RE$1 = /[?&]macro=true(?:&|$)/;
+const TYPE_PARAM_RE = /[?&]type=([^?&]+)/;
+const LANG_PARAM_RE = /[?&]lang=([^?&]+)/;
 function parseMacroQuery(id) {
-  const { search } = parseURL(decodeURIComponent(isAbsolute(id) ? pathToFileURL(id).href : id).replace(/\?macro=true$/, ""));
-  const query = parseQuery(search);
-  if (id.includes("?macro=true")) {
-    return { macro: "true", ...query };
+  const { search } = parseModuleId(id);
+  const query = {
+    type: TYPE_PARAM_RE.exec(search)?.[1],
+    lang: LANG_PARAM_RE.exec(search)?.[1] ?? void 0
+  };
+  if (MACRO_QUERY_RE$1.test(search)) {
+    query.macro = "true";
   }
   return query;
 }
@@ -1178,13 +1099,13 @@ const RouteInjectionPlugin = (nuxt) => createUnplugin(() => {
 });
 
 const OPTIONAL_PARAM_RE = /^\/?:.*(?:\?|\(\.\*\)\*)$/;
-const runtimeDir = resolve(distDir, "pages/runtime");
 const pagesImportPresets = [
-  { imports: ["definePageMeta"], from: resolve(runtimeDir, "composables") },
+  { imports: ["definePageMeta"], from: "#app/composables/pages" },
+  { imports: ["PageMeta"], from: "#app/composables/pages", type: true },
   { imports: ["useLink"], from: "vue-router" }
 ];
 const routeRulesPresets = [
-  { imports: ["defineRouteRules"], from: resolve(runtimeDir, "composables") }
+  { imports: ["defineRouteRules"], from: "#app/composables/pages" }
 ];
 async function resolveRouterOptions(nuxt, builtInRouterOptions) {
   const context = {
@@ -1210,6 +1131,7 @@ const pagesModule = defineNuxtModule({
     pattern: `**/*{${nuxt.options.extensions.join(",")}}`
   }),
   async setup(_options, nuxt) {
+    const runtimeDir = resolve(distDir, "pages/runtime");
     const options = typeof _options === "boolean" ? { enabled: _options ?? nuxt.options.pages, pattern: `**/*{${nuxt.options.extensions.join(",")}}` } : { ..._options };
     options.pattern = Array.isArray(options.pattern) ? [...new Set(options.pattern)] : options.pattern;
     let inlineRulesCache = {};
@@ -1224,19 +1146,34 @@ const pagesModule = defineNuxtModule({
         };
       });
     }
-    const resolvePagesRoutes$1 = async (pattern, nuxt2) => {
-      const pages = await resolvePagesRoutes(pattern, nuxt2);
-      if (nuxt2.options.experimental.inlineRouteRules) {
+    const useExperimentalTypedPages = nuxt.options.experimental.typedPages;
+    const builtInRouterOptions = await findPath(resolve(runtimeDir, "router.options")) || resolve(runtimeDir, "router.options");
+    const pagesDirs = getLayerDirectories(nuxt).map((dirs) => dirs.appPages);
+    const pagesCtx = nuxt.options.dev ? createPagesContext({
+      roots: pagesDirs,
+      shouldUseServerComponents: !!nuxt.options.experimental.componentIslands
+    }) : void 0;
+    const isPagePattern = picomatch(
+      Array.isArray(options.pattern) ? options.pattern : [options.pattern]
+    );
+    const handleRouteRules = async (pages) => {
+      if (nuxt.options.experimental.inlineRouteRules) {
         const routeRules = globRouteRulesFromPages(pages);
         await updateRouteConfig?.(routeRules);
       } else {
         removePagesRules(pages);
       }
+    };
+    const resolvePagesRoutes$1 = async (pattern, nuxt2) => {
+      const pages = await resolvePagesRoutes(pattern, nuxt2, pagesCtx);
+      await handleRouteRules(pages);
       return pages;
     };
-    const useExperimentalTypedPages = nuxt.options.experimental.typedPages;
-    const builtInRouterOptions = await findPath(resolve(runtimeDir, "router.options")) || resolve(runtimeDir, "router.options");
-    const pagesDirs = getLayerDirectories(nuxt).map((dirs) => dirs.appPages);
+    const augmentAndResolvePages = async (pages, trackedFiles, nuxt2) => {
+      const resolved = await augmentAndResolve(pages, trackedFiles, nuxt2);
+      await handleRouteRules(resolved);
+      return resolved;
+    };
     nuxt.options.alias["#vue-router"] = "vue-router";
     const routerPath = await resolveTypePath("vue-router", "", nuxt.options.modulesDir) || "vue-router";
     nuxt.hook("prepare:types", ({ tsConfig }) => {
@@ -1369,7 +1306,7 @@ const pagesModule = defineNuxtModule({
               route.addToMeta(page.meta);
             }
             if (page.alias) {
-              route.addAlias(page.alias);
+              route.addAlias(Array.isArray(page.alias) ? page.alias : [page.alias]);
             }
             if (page.name) {
               route.name = page.name;
@@ -1387,7 +1324,6 @@ const pagesModule = defineNuxtModule({
       };
       nuxt.hook("prepare:types", ({ references }) => {
         references.push({ path: declarationFile });
-        references.push({ types: "unplugin-vue-router/client" });
       });
       const context = createRoutesContext(resolveOptions(typedRouterOptions));
       await mkdir(dirname(declarationFile), { recursive: true });
@@ -1405,8 +1341,17 @@ const pagesModule = defineNuxtModule({
         }
       });
     }
-    nuxt.hook("prepare:types", ({ references }) => {
+    nuxt.hook("prepare:types", ({ references, tsConfig }) => {
       references.push({ types: useExperimentalTypedPages ? "vue-router/auto-routes" : "vue-router" });
+      tsConfig.vueCompilerOptions ||= {};
+      tsConfig.vueCompilerOptions.plugins ||= [];
+      tsConfig.vueCompilerOptions.plugins.push("vue-router/volar/sfc-route-blocks");
+      if (useExperimentalTypedPages) {
+        tsConfig.vueCompilerOptions.plugins.push({
+          name: "vue-router/volar/sfc-typed-router",
+          options: { rootDir: nuxt.options.rootDir }
+        });
+      }
     });
     nuxt.hook("imports:sources", (sources) => {
       const routerImports = sources.find((s) => s.from === "#app/composables/router" && s.imports.includes("onBeforeRouteLeave"));
@@ -1434,7 +1379,28 @@ const pagesModule = defineNuxtModule({
       if (event === "change" && !shouldAlwaysRegenerate) {
         return;
       }
-      if (shouldAlwaysRegenerate || updateTemplatePaths.some((dir) => path.startsWith(dir))) {
+      const layerIndex = pagesDirs.findIndex((dir) => path.startsWith(dir));
+      const isInPagesDir = layerIndex !== -1;
+      if (pagesCtx && isInPagesDir && !shouldAlwaysRegenerate) {
+        try {
+          if (event === "add") {
+            const relativeToDir = relative(pagesDirs[layerIndex], path);
+            if (!isPagePattern(relativeToDir) || isIgnored(path)) {
+              return;
+            }
+            pagesCtx.addFile(path, layerIndex);
+          } else if (event === "unlink") {
+            if (!pagesCtx.removeFile(path)) {
+              return;
+            }
+          }
+          const pages = pagesCtx.emit();
+          nuxt.apps.default.pages = await augmentAndResolvePages(pages, pagesCtx.trackedFiles, nuxt);
+        } catch (err) {
+          logger.warn("Incremental route update failed, performing full rebuild", err);
+          nuxt.apps.default.pages = await resolvePagesRoutes$1(options.pattern, nuxt);
+        }
+      } else if (shouldAlwaysRegenerate || updateTemplatePaths.some((dir) => path.startsWith(dir))) {
         nuxt.apps.default.pages = await resolvePagesRoutes$1(options.pattern, nuxt);
       }
     });
@@ -1491,7 +1457,7 @@ const pagesModule = defineNuxtModule({
         ...nitro.options.ssrRoutes || [],
         ...toRou3Patterns(nuxt.apps.default?.pages || [])
       ];
-      if (!nitro.options.static && !nitro.options.prerender.crawlLinks) {
+      if (!nitro.options.static) {
         const routeRulesRouter = createRouter();
         for (const [route, rules] of Object.entries(nitro.options.routeRules)) {
           addRoute(routeRulesRouter, void 0, route, rules);
@@ -1673,23 +1639,25 @@ const pagesModule = defineNuxtModule({
     addTypeTemplate({
       filename: "types/layouts.d.ts",
       getContents: ({ app }) => {
-        const imports = /* @__PURE__ */ new Set();
-        const interfaceKeyValues = /* @__PURE__ */ new Map();
-        for (const layout of Object.values(app.layouts)) {
-          const varName = genSafeVariableName(layout.name);
-          imports.add(genImport(layout.file, varName));
-          interfaceKeyValues.set(layout.name, varName);
-        }
         return [
-          ...Array.from(imports),
           "import type { ComputedRef, MaybeRef } from 'vue'",
+          "",
+          "type ComponentProps<T> = T extends new(...args: any) => { $props: infer P } ? NonNullable<P>",
+          "  : T extends (props: infer P, ...args: any) => any ? P",
+          "  : {}",
+          "",
           "declare module 'nuxt/app' {",
           "  interface NuxtLayouts {",
-          ...Array.from(interfaceKeyValues.entries()).map(([key, value]) => `    '${key}': InstanceType<typeof ${value}>['$props'],`),
-          "}",
+          ...Object.values(app.layouts).map((layout) => `    ${genObjectKey(layout.name)}: ComponentProps<${genInlineTypeImport(layout.file)}>`),
+          "  }",
           "  export type LayoutKey = keyof NuxtLayouts extends never ? string : keyof NuxtLayouts",
           "  interface PageMeta {",
-          "    layout?: MaybeRef<LayoutKey | false> | ComputedRef<LayoutKey | false>",
+          "    layout?: MaybeRef<LayoutKey | false> | ComputedRef<LayoutKey | false> | {",
+          "      [K in LayoutKey]: {",
+          "        name?: MaybeRef<K | false> | ComputedRef<K | false>",
+          "        props?: NuxtLayouts[K]",
+          "      }",
+          "    }[LayoutKey]",
           "  }",
           "}"
         ].join("\n");
@@ -1700,9 +1668,10 @@ const pagesModule = defineNuxtModule({
         filename: "types/view-transitions.d.ts",
         getContents: () => {
           return [
+            "import type { ViewTransitionPageOptions } from '../types/config'",
             "declare module 'nuxt/app' {",
             "  interface PageMeta {",
-            "    viewTransition?: boolean | 'always'",
+            "    viewTransition?: ViewTransitionPageOptions['enabled'] | ViewTransitionPageOptions",
             "  }",
             "}",
             "export {}"
@@ -1729,12 +1698,19 @@ if (import.meta.hot) {
       import.meta.hot.invalidate('[nuxt] Cannot replace routes because there is no active router. Reloading.')
       return
     }
+    const addedRoutes = router.getRoutes().filter(r => !r._initial)
     router.clearRoutes()
     const routes = generateRoutes(mod.default || mod)
     function addRoutes (routes) {
       for (const route of routes) {
         router.addRoute(route)
       }
+      for (const route of router.getRoutes()) {
+        route._initial = true
+      }
+      for (const route of addedRoutes) {
+        router.addRoute(route)
+      }
       router.isReady().then(() => {
         // Resolve the current path against the new routes to get updated meta
         const newRoute = router.resolve(router.currentRoute.value.fullPath)
@@ -1758,12 +1734,16 @@ export function handleHotUpdate(_router, _generateRoutes) {
     import.meta.hot.data ||= {}
     import.meta.hot.data.router = _router
     import.meta.hot.data.generateRoutes = _generateRoutes
+    for (const route of _router.getRoutes()) {
+      route._initial = true
+    }
   }
 }
 `
 );
 
 const UNHEAD_LIB_RE = /node_modules[/\\](?:@unhead[/\\][^/\\]+|unhead)[/\\]/;
+const NUXT_HEAD_RE = /node_modules[/\\]nuxt[/\\]dist[/\\]head[/\\]runtime[/\\]/;
 function toImports(specifiers) {
   return specifiers.map((specifier) => {
     const imported = specifier.imported;
@@ -1779,7 +1759,7 @@ const UnheadImportsPlugin = (options) => createUnplugin(() => {
     enforce: "post",
     transformInclude(id) {
       id = normalize(id);
-      return (isJS(id) || isVue(id, { type: ["script"] })) && !id.startsWith("virtual:") && !id.startsWith(normalize(distDir)) && !UNHEAD_LIB_RE.test(id);
+      return (isJS(id) || isVue(id, { type: ["script"] })) && !id.startsWith("virtual:") && !id.startsWith(normalize(distDir)) && !UNHEAD_LIB_RE.test(id) && !NUXT_HEAD_RE.test(id);
     },
     transform: {
       filter: {
@@ -1916,7 +1896,7 @@ const granularAppPresets = [
     from: "#app/composables/component"
   },
   {
-    imports: ["useAsyncData", "useLazyAsyncData", "useNuxtData", "refreshNuxtData", "clearNuxtData"],
+    imports: ["useAsyncData", "useLazyAsyncData", "useNuxtData", "refreshNuxtData", "clearNuxtData", "createUseAsyncData"],
     from: "#app/composables/asyncData"
   },
   {
@@ -1936,7 +1916,7 @@ const granularAppPresets = [
     from: "#app/composables/error"
   },
   {
-    imports: ["useFetch", "useLazyFetch"],
+    imports: ["useFetch", "useLazyFetch", "createUseFetch"],
     from: "#app/composables/fetch"
   },
   {
@@ -1987,6 +1967,10 @@ const granularAppPresets = [
     imports: ["useRouteAnnouncer"],
     from: "#app/composables/route-announcer"
   },
+  {
+    imports: ["useAnnouncer"],
+    from: "#app/composables/announcer"
+  },
   {
     imports: ["useRuntimeHook"],
     from: "#app/composables/runtime-hook"
@@ -2249,7 +2233,7 @@ const componentsIslandsTemplate = {
   }
 };
 const NON_VUE_RE = /\b\.(?!vue)\w+$/g;
-function resolveComponentTypes(app, baseDir) {
+function resolveComponentTypes(app, baseDir, dynamic) {
   const serverPlaceholderPath = resolve(distDir, "app/components/server-placeholder");
   const componentTypes = [];
   for (const c of app.components) {
@@ -2257,7 +2241,7 @@ function resolveComponentTypes(app, baseDir) {
       continue;
     }
     const filePath = c.declarationPath || c.filePath;
-    let type = genDynamicTypeImport(isAbsolute(filePath) ? relative(baseDir, filePath).replace(NON_VUE_RE, "") : filePath.replace(NON_VUE_RE, ""), c.export);
+    let type = dynamic ? renderDynamicTypeImport(baseDir, filePath, c.export) : renderLegacyTypeImport(baseDir, filePath, c.export);
     if (c.mode === "server") {
       if (app.components.some((other) => other.pascalName === c.pascalName && other.mode === "client")) {
         if (c.filePath.startsWith(serverPlaceholderPath)) {
@@ -2271,6 +2255,12 @@ function resolveComponentTypes(app, baseDir) {
   }
   return componentTypes;
 }
+function renderDynamicTypeImport(baseDir, filePath, exportName) {
+  return genDynamicTypeImport(isAbsolute(filePath) ? relative(baseDir, filePath).replace(NON_VUE_RE, "") : filePath.replace(NON_VUE_RE, ""), exportName);
+}
+function renderLegacyTypeImport(baseDir, filePath, exportName) {
+  return `typeof ${genDynamicImport(isAbsolute(filePath) ? relative(baseDir, filePath).replace(NON_VUE_RE, "") : filePath.replace(NON_VUE_RE, ""), { wrapper: false })}['${exportName}']`;
+}
 const islandType = "type IslandComponent<T> = DefineComponent<{}, {refresh: () => Promise<void>}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, SlotsType<{ fallback: { error: unknown } }>> & T";
 const hydrationTypes = `
 type HydrationStrategies = {
@@ -2288,7 +2278,7 @@ const componentsDeclarationTemplate = {
   filename: "components.d.ts",
   write: true,
   getContents: ({ app, nuxt }) => {
-    const componentTypes = resolveComponentTypes(app, nuxt.options.buildDir);
+    const componentTypes = resolveComponentTypes(app, nuxt.options.buildDir, nuxt.options.experimental.typescriptPlugin);
     return `
 import type { DefineComponent, SlotsType } from 'vue'
 ${nuxt.options.experimental.componentIslands ? islandType : ""}
@@ -2304,14 +2294,14 @@ export const componentNames: string[]
 const componentsTypeTemplate = {
   filename: "types/components.d.ts",
   getContents: ({ app, nuxt }) => {
-    const componentTypes = resolveComponentTypes(app, join(nuxt.options.buildDir, "types"));
+    const componentTypes = resolveComponentTypes(app, join(nuxt.options.buildDir, "types"), nuxt.options.experimental.typescriptPlugin);
     return `
 import type { DefineComponent, SlotsType } from 'vue'
 ${nuxt.options.experimental.componentIslands ? islandType : ""}
 ${hydrationTypes}
 interface _GlobalComponents {
-${componentTypes.map(([pascalName, type]) => `  '${pascalName}': ${type}`).join("\n")}
-${componentTypes.map(([pascalName, type]) => `  'Lazy${pascalName}': LazyComponent<${type}>`).join("\n")}
+${componentTypes.map(([pascalName, type]) => `  ${genObjectKey(pascalName)}: ${type}`).join("\n")}
+${componentTypes.map(([pascalName, type]) => `  ${genObjectKey(`Lazy${pascalName}`)}: LazyComponent<${type}>`).join("\n")}
 }
 
 declare module 'vue' {
@@ -2618,7 +2608,7 @@ const IslandsTransformPlugin = (options) => createUnplugin((_options, meta) => {
       const islands = components.filter(
         (component) => component.island || component.mode === "server" && !components.some((c) => c.pascalName === component.pascalName && c.mode === "client")
       );
-      const { pathname } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+      const { pathname } = parseModuleId(normalize(id));
       return islands.some((c) => c.filePath === pathname);
     },
     transform: {
@@ -2819,6 +2809,7 @@ function TransformPlugin$1(nuxt, options) {
     virtualImports: ["#components"],
     injectAtEnd: true
   });
+  const rootDirWithSlash = nuxt.options.rootDir.replace(/\/?$/, "/");
   function getComponentsImports() {
     const components = options.getComponents(options.mode);
     const clientOrServerModes = /* @__PURE__ */ new Set(["client", "server"]);
@@ -2852,11 +2843,11 @@ function TransformPlugin$1(nuxt, options) {
           id: COMPONENT_QUERY_RE
         },
         handler(_code, id) {
-          const { search } = parseURL(id);
-          const query = parseQuery$1(search);
-          const mode = query.nuxt_component;
+          const { search } = parseModuleId(id);
+          const params = new URLSearchParams(search);
+          const mode = params.get("nuxt_component");
           const bare = id.replace(/\?.*/, "");
-          const componentExport = query.nuxt_component_export || "default";
+          const componentExport = params.get("nuxt_component_export") || "default";
           const exportWording = componentExport === "default" ? "export default" : `export const ${componentExport} =`;
           if (mode === "async") {
             return {
@@ -2885,7 +2876,7 @@ function TransformPlugin$1(nuxt, options) {
               map: null
             };
           } else if (mode === "server" || mode === "server,async") {
-            const name = query.nuxt_component_name;
+            const name = params.get("nuxt_component_name");
             return {
               code: [
                 `import { createServerComponent } from ${JSON.stringify(options.serverComponentRuntime)}`,
@@ -2911,9 +2902,15 @@ function TransformPlugin$1(nuxt, options) {
           code: /#components/
         },
         async handler(code, id) {
-          const pkg = isAbsolute(id) && /node_modules[\\/](?!\.virtual)/.test(id) ? await readPackage(id, { try: true }) : void 0;
-          if (isObject(pkg) && isObject(pkg.imports) && Object.hasOwn(pkg.imports, "#components")) {
-            return;
+          if (isAbsolute(id) && (/node_modules[\\/](?!\.virtual)/.test(id) || !id.includes(rootDirWithSlash))) {
+            let pkg;
+            try {
+              pkg = await readPackage(id);
+            } catch {
+            }
+            if (isObject(pkg) && isObject(pkg.imports) && Object.keys(pkg.imports).some((k) => k.includes("#components"))) {
+              return;
+            }
           }
           componentUnimport.modifyDynamicImports((imports) => {
             imports.length = 0;
@@ -2942,70 +2939,71 @@ const TreeShakeTemplatePlugin = (options) => createUnplugin(() => {
   return {
     name: "nuxt:tree-shake-template",
     enforce: "post",
-    transformInclude(id) {
-      const { pathname } = parseURL(decodeURIComponent(pathToFileURL(id).href));
-      return pathname.endsWith(".vue");
-    },
-    transform(code, id) {
-      const components = options.getComponents();
-      if (!regexpMap.has(components)) {
-        const serverPlaceholderPath = resolve(distDir, "app/components/server-placeholder");
-        const clientOnlyComponents = components.filter((c) => c.mode === "client" && !components.some((other) => other.mode !== "client" && other.pascalName === c.pascalName && !other.filePath.startsWith(serverPlaceholderPath))).flatMap((c) => [c.pascalName, c.kebabName.replaceAll("-", "_")]).concat(["ClientOnly", "client_only"]);
-        regexpMap.set(components, [new RegExp(`(${clientOnlyComponents.join("|")})`), new RegExp(`^(${clientOnlyComponents.map((c) => `(?:(?:_unref\\()?(?:_component_)?(?:Lazy|lazy_)?${c}\\)?)`).join("|")})$`), clientOnlyComponents]);
-      }
-      const s = new MagicString(code);
-      const [COMPONENTS_RE, COMPONENTS_IDENTIFIERS_RE] = regexpMap.get(components);
-      if (!COMPONENTS_RE.test(code)) {
-        return;
-      }
-      const componentsToRemoveSet = /* @__PURE__ */ new Set();
-      const { program: ast } = parseAndWalk(code, id, (node) => {
-        if (!isSsrRender(node)) {
-          return;
+    transform: {
+      filter: {
+        id: { include: VUE_ID_RE }
+      },
+      handler(code, id) {
+        const components = options.getComponents();
+        if (!regexpMap.has(components)) {
+          const serverPlaceholderPath = resolve(distDir, "app/components/server-placeholder");
+          const clientOnlyComponents = components.filter((c) => c.mode === "client" && !components.some((other) => other.mode !== "client" && other.pascalName === c.pascalName && !other.filePath.startsWith(serverPlaceholderPath))).flatMap((c) => [c.pascalName, c.kebabName.replaceAll("-", "_")]).concat(["ClientOnly", "client_only"]);
+          regexpMap.set(components, [new RegExp(`(${clientOnlyComponents.join("|")})`), new RegExp(`^(${clientOnlyComponents.map((c) => `(?:(?:_unref\\()?(?:_component_)?(?:Lazy|lazy_)?${c}\\)?)`).join("|")})$`), clientOnlyComponents]);
         }
-        const [componentCall, _, children] = node.arguments;
-        if (!componentCall) {
+        const s = new MagicString(code);
+        const [COMPONENTS_RE, COMPONENTS_IDENTIFIERS_RE] = regexpMap.get(components);
+        if (!COMPONENTS_RE.test(code)) {
           return;
         }
-        if (componentCall.type === "Identifier" || componentCall.type === "MemberExpression" || componentCall.type === "CallExpression") {
-          const componentName = getComponentName(node);
-          if (!componentName || !COMPONENTS_IDENTIFIERS_RE.test(componentName) || children?.type !== "ObjectExpression") {
+        const componentsToRemoveSet = /* @__PURE__ */ new Set();
+        const { program: ast } = parseAndWalk(code, id, (node) => {
+          if (!isSsrRender(node)) {
             return;
           }
-          const isClientOnlyComponent = CLIENT_ONLY_NAME_RE.test(componentName);
-          const slotsToRemove = isClientOnlyComponent ? children.properties.filter((prop) => prop.type === "Property" && prop.key.type === "Identifier" && !PLACEHOLDER_EXACT_RE.test(prop.key.name)) : children.properties;
-          for (const slot of slotsToRemove) {
-            s.remove(slot.start, slot.end + 1);
-            const removedCode = `({${code.slice(slot.start, slot.end + 1)}})`;
-            const currentState = s.toString();
-            parseAndWalk(removedCode, id, (node2) => {
-              if (!isSsrRender(node2)) {
-                return;
-              }
-              const name = getComponentName(node2);
-              if (!name) {
-                return;
-              }
-              const nameToRemove = isComponentNotCalledInSetup(currentState, id, name);
-              if (nameToRemove) {
-                componentsToRemoveSet.add(nameToRemove);
-              }
-            });
+          const [componentCall, _, children] = node.arguments;
+          if (!componentCall) {
+            return;
+          }
+          if (componentCall.type === "Identifier" || componentCall.type === "MemberExpression" || componentCall.type === "CallExpression") {
+            const componentName = getComponentName(node);
+            if (!componentName || !COMPONENTS_IDENTIFIERS_RE.test(componentName) || children?.type !== "ObjectExpression") {
+              return;
+            }
+            const isClientOnlyComponent = CLIENT_ONLY_NAME_RE.test(componentName);
+            const slotsToRemove = isClientOnlyComponent ? children.properties.filter((prop) => prop.type === "Property" && prop.key.type === "Identifier" && !PLACEHOLDER_EXACT_RE.test(prop.key.name)) : children.properties;
+            for (const slot of slotsToRemove) {
+              s.remove(slot.start, slot.end + 1);
+              const removedCode = `({${code.slice(slot.start, slot.end + 1)}})`;
+              const currentState = s.toString();
+              parseAndWalk(removedCode, id, (node2) => {
+                if (!isSsrRender(node2)) {
+                  return;
+                }
+                const name = getComponentName(node2);
+                if (!name) {
+                  return;
+                }
+                const nameToRemove = isComponentNotCalledInSetup(currentState, id, name);
+                if (nameToRemove) {
+                  componentsToRemoveSet.add(nameToRemove);
+                }
+              });
+            }
           }
+        });
+        const componentsToRemove = [...componentsToRemoveSet];
+        const removedNodes = /* @__PURE__ */ new WeakSet();
+        for (const componentName of componentsToRemove) {
+          removeImportDeclaration(ast, componentName, s);
+          removeVariableDeclarator(ast, componentName, s, removedNodes);
+          removeFromSetupReturn(ast, componentName, s);
+        }
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
+          };
         }
-      });
-      const componentsToRemove = [...componentsToRemoveSet];
-      const removedNodes = /* @__PURE__ */ new WeakSet();
-      for (const componentName of componentsToRemove) {
-        removeImportDeclaration(ast, componentName, s);
-        removeVariableDeclarator(ast, componentName, s, removedNodes);
-        removeFromSetupReturn(ast, componentName, s);
-      }
-      if (s.hasChanged()) {
-        return {
-          code: s.toString(),
-          map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
-        };
       }
     }
   };
@@ -3916,102 +3914,1392 @@ function addDeclarationTemplates(ctx, options) {
         if (!nitroImport || i.dtsDisabled || nitroImport.dtsDisabled) {
           continue;
         }
+        if (i.from !== nitroImport.from) {
+          continue;
+        }
         sharedImports.push(i);
       }
       await cacheImportPaths(sharedImports);
-      return GENERATED_BY_COMMENT + toTypeDeclarationFile(sharedImports, { resolvePath: r });
+      const handCraftedDeclarations = `
+  const useRuntimeConfig: (event?: import('h3').H3Event) => import('nuxt/schema').RuntimeConfig
+  const useAppConfig: () => import('nuxt/schema').AppConfig
+  const defineAppConfig: <C extends import('nuxt/schema').AppConfigInput>(config: C) => C
+  const createError: typeof import('h3')['createError']
+  const setResponseStatus: typeof import('h3')['setResponseStatus']`;
+      return GENERATED_BY_COMMENT + toTypeDeclarationFile(sharedImports, { resolvePath: r }).replace(
+        /^declare global \{$/m,
+        `declare global {${handCraftedDeclarations}`
+      );
     }
   });
 }
 
-const runtimeDependencies = [
-  // other deps
-  "devalue",
-  "klona",
-  // unjs ecosystem
-  "defu",
-  "ufo",
-  "h3",
-  "destr",
-  "consola",
-  "hookable",
-  "unctx",
-  "cookie-es",
-  "perfect-debounce",
-  "ohash",
-  "pathe",
-  "uncrypto"
-];
-
-const version = "4.3.0";
-const pkg = {
-	version: version};
-
-function createImportProtectionPatterns(nuxt, options) {
-  const patterns = [];
-  const context = contextFlags[options.context];
-  patterns.push([
-    /^(nuxt|nuxt3|nuxt-nightly)$/,
-    `\`nuxt\`, or \`nuxt-nightly\` cannot be imported directly in ${context}.` + (options.context === "nuxt-app" ? " Instead, import runtime Nuxt composables from `#app` or `#imports`." : "")
-  ]);
-  patterns.push([
-    /^((~|~~|@|@@)?\/)?nuxt\.config(\.|$)/,
-    "Importing directly from a `nuxt.config` file is not allowed. Instead, use runtime config or a module."
-  ]);
-  patterns.push([/(^|node_modules\/)@vue\/composition-api/]);
-  for (const mod of nuxt.options._installedModules) {
-    if (mod.entryPath) {
-      patterns.push([
-        new RegExp(`^${escapeRE(mod.entryPath)}$`),
-        "Importing directly from module entry-points is not allowed."
-      ]);
-    }
-  }
-  for (const i of [/(^|node_modules\/)@nuxt\/(cli|kit|test-utils)/, /(^|node_modules\/)nuxi/, /(^|node_modules\/)nitro(?:pack)?(?:-nightly)?(?:$|\/)(?!(?:dist\/)?(?:node_modules|presets|runtime|types))/, /(^|node_modules\/)nuxt\/(config|kit|schema)/]) {
-    patterns.push([i, `This module cannot be imported in ${context}.`]);
-  }
-  if (options.context === "nitro-app" || options.context === "shared") {
-    for (const i of ["#app", /^#build(\/|$)/]) {
-      patterns.push([i, `Vue app aliases are not allowed in ${context}.`]);
+function createScanPluginContext(code, filePath) {
+  let parseResult = null;
+  let parsedStaticImports = null;
+  const pluginScanThisContext = {
+    walkParsed: (...args) => {
+      if (parseResult) {
+        const options = typeof args[0] === "function" ? { enter: args[0] } : args[0];
+        walk(parseResult.program, options);
+        return parseResult;
+      }
+      parseResult = parseAndWalk.call(null, code, filePath, args[0]);
+      return parseResult;
+    },
+    getParsedStaticImports: () => {
+      if (parsedStaticImports) {
+        return parsedStaticImports;
+      }
+      const imports = findStaticImports(code);
+      parsedStaticImports = imports.map((i) => parseStaticImport(i));
+      return parsedStaticImports;
     }
+  };
+  return pluginScanThisContext;
+}
+function matchWithStringOrRegex(value, matcher) {
+  if (typeof matcher === "string") {
+    return value === matcher;
+  } else if (matcher instanceof RegExp) {
+    return matcher.test(value);
   }
-  if (options.context === "nuxt-app" || options.context === "shared") {
-    patterns.push([
-      new RegExp(escapeRE(relative(nuxt.options.srcDir, resolve(nuxt.options.srcDir, nuxt.options.serverDir || "server"))) + "\\/(api|routes|middleware|plugins)\\/"),
-      `Importing from server is not allowed in ${context}.`
-    ]);
-    patterns.push([
-      /^#server(\/|$)/,
-      `Server aliases are not allowed in ${context}.`
-    ]);
-  }
-  return patterns;
+  return false;
 }
-const contextFlags = {
-  "nitro-app": "server runtime",
-  "nuxt-app": "the Vue part of your app",
-  "shared": "the #shared directory"
-};
 
-const TRANSFORM_MARKER = "/* _processed_nuxt_unctx_transform */\n";
-const TRANSFORM_MARKER_RE = /^\/\* _processed_nuxt_unctx_transform \*\/\n/;
-const UnctxTransformPlugin = (options) => createUnplugin(() => {
-  const transformer = createTransformer(options.transformerOptions);
-  return {
-    name: "unctx:transform",
-    enforce: "post",
-    transformInclude(id) {
-      return isVue(id, { type: ["template", "script"] }) || isJS(id);
-    },
-    transform: {
-      filter: {
-        ...transformer.filter,
-        code: {
-          ...transformer.filter.code,
-          exclude: TRANSFORM_MARKER_RE
-        }
-      },
-      handler(code) {
+function processImports(imports, alias) {
+  const directImports = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Map();
+  for (const i of imports) {
+    const resolvedSpecifier = stripExtension(resolveAlias$1(i.specifier, alias));
+    const namedImports = i.namedImports ?? {};
+    for (const originalIdentifier in namedImports) {
+      const localIdentifier = namedImports[originalIdentifier] || originalIdentifier;
+      directImports.set(localIdentifier, {
+        originalName: originalIdentifier,
+        source: resolvedSpecifier
+      });
+    }
+    if (i.namespacedImport || i.defaultImport) {
+      if (!namespaces.has(resolvedSpecifier)) {
+        namespaces.set(resolvedSpecifier, {
+          namespaces: /* @__PURE__ */ new Set()
+        });
+      }
+    }
+    if (i.defaultImport) {
+      const namespace = i.defaultImport;
+      const entry = namespaces.get(resolvedSpecifier);
+      entry.namespaces.add(namespace);
+      directImports.set(i.defaultImport, {
+        originalName: "default",
+        source: resolvedSpecifier
+      });
+    } else if (i.namespacedImport) {
+      const namespace = i.namespacedImport;
+      const entry = namespaces.get(resolvedSpecifier);
+      entry.namespaces.add(namespace);
+    }
+  }
+  return {
+    directImports,
+    namespaces
+  };
+}
+function parseStaticFunctionCall(node, filter) {
+  const callExpression = node.type === "CallExpression" ? node : node.type === "ChainExpression" && node.expression.type === "CallExpression" ? node.expression : null;
+  if (!callExpression) {
+    return null;
+  }
+  let functionName;
+  let identifierNode;
+  if (callExpression.callee.type === "Identifier") {
+    functionName = callExpression.callee.name;
+    identifierNode = callExpression.callee;
+  } else if (callExpression.callee.type === "ParenthesizedExpression") {
+    if (callExpression.callee.expression.type === "Identifier") {
+      functionName = callExpression.callee.expression.name;
+      identifierNode = callExpression.callee;
+    } else if ((callExpression.callee.expression.type === "TSAsExpression" || callExpression.callee.expression.type === "TSTypeAssertion" || callExpression.callee.expression.type === "TSNonNullExpression") && callExpression.callee.expression.expression.type === "Identifier") {
+      functionName = callExpression.callee.expression.expression.name;
+      identifierNode = callExpression.callee;
+    }
+  }
+  if (functionName && identifierNode && filter.test(functionName)) {
+    return {
+      name: functionName,
+      namespace: null,
+      node: identifierNode,
+      callExpression
+    };
+  }
+  function getParsedMemberExpression(memberExpression) {
+    let memberObjectName;
+    if (memberExpression.object.type === "Identifier") {
+      memberObjectName = memberExpression.object.name;
+    } else if (memberExpression.object.type === "ParenthesizedExpression") {
+      if (memberExpression.object.expression.type === "Identifier") {
+        memberObjectName = memberExpression.object.expression.name;
+      } else if ((memberExpression.object.expression.type === "TSAsExpression" || memberExpression.object.expression.type === "TSTypeAssertion" || memberExpression.object.expression.type === "TSNonNullExpression") && memberExpression.object.expression.expression.type === "Identifier") {
+        memberObjectName = memberExpression.object.expression.expression.name;
+      }
+    }
+    if (memberObjectName) {
+      if (memberExpression.property.type === "Identifier" && filter.test(memberExpression.property.name)) {
+        return {
+          name: memberExpression.property.name,
+          namespace: memberObjectName,
+          node: memberExpression.property
+        };
+      }
+      if (memberExpression.property.type === "Literal" && typeof memberExpression.property.value === "string" && filter.test(memberExpression.property.value)) {
+        return {
+          name: memberExpression.property.value,
+          namespace: memberObjectName,
+          node: memberExpression
+        };
+      }
+    }
+    return null;
+  }
+  if (callExpression.callee.type === "MemberExpression") {
+    const val = getParsedMemberExpression(callExpression.callee);
+    if (val) {
+      return {
+        ...val,
+        callExpression
+      };
+    }
+  } else if (callExpression.callee.type === "ParenthesizedExpression" && callExpression.callee.expression.type === "MemberExpression") {
+    const val = getParsedMemberExpression(callExpression.callee.expression);
+    if (val) {
+      return {
+        ...val,
+        node: callExpression.callee,
+        callExpression
+      };
+    }
+  }
+  return null;
+}
+function parseStaticExportIdentifiers(node, filter) {
+  if (node.type === "ExportNamedDeclaration" && node.exportKind !== "type") {
+    if (node.declaration?.type === "VariableDeclaration") {
+      return node.declaration.declarations.map((d) => {
+        if (d.id.type === "Identifier" && (true)) {
+          return {
+            localName: d.id.name,
+            exportedName: d.id.name
+          };
+        }
+        return null;
+      }).filter((v) => !!v);
+    }
+    if (node.declaration?.type === "FunctionDeclaration") {
+      if (node.declaration.id?.type === "Identifier" && (true)) {
+        return [{
+          localName: node.declaration.id.name,
+          exportedName: node.declaration.id.name
+        }];
+      }
+      return [];
+    }
+    if (node.declaration?.type === "ClassDeclaration") {
+      if (node.declaration.id?.type === "Identifier" && (true)) {
+        return [{
+          localName: node.declaration.id.name,
+          exportedName: node.declaration.id.name
+        }];
+      }
+      return [];
+    }
+    if (node.specifiers && node.specifiers.length) {
+      return node.specifiers.map((s) => {
+        if (s.exported.type === "Identifier" && s.exportKind !== "type" && s.local.type === "Identifier" && (true)) {
+          return {
+            localName: s.local.name,
+            exportedName: s.exported.name
+          };
+        }
+        return null;
+      }).filter((v) => !!v);
+    }
+    return [];
+  }
+  if (node.type === "ExportDefaultDeclaration" && (!node.exportKind || node.exportKind === "value")) {
+    if (node.declaration.type === "Identifier") {
+      return [{
+        localName: node.declaration.name,
+        exportedName: "default"
+      }];
+    }
+    if (node.declaration.type === "FunctionDeclaration") {
+      if (node.declaration.id?.type === "Identifier") {
+        return [{
+          localName: node.declaration.id.name,
+          exportedName: "default"
+        }];
+      }
+      return [];
+    }
+    if (node.declaration.type === "ClassDeclaration") {
+      if (node.declaration.id?.type === "Identifier") {
+        return [{
+          localName: node.declaration.id.name,
+          exportedName: "default"
+        }];
+      }
+      return [];
+    }
+  }
+  if (node.type === "TSExportAssignment") {
+    if (node.expression.type === "Identifier") {
+      {
+        return [{
+          localName: node.expression.name,
+          exportedName: "default"
+        }];
+      }
+    }
+  }
+  return [];
+}
+
+function parseKeyedFunctionFactory(node, filter, scopeTracker) {
+  if (node.type === "ExportNamedDeclaration") {
+    let processVariableDeclarator = function(node2) {
+      if (node2.init?.type !== "CallExpression" && node2.init?.type !== "ChainExpression") {
+        return;
+      }
+      const functionCallMeta = parseStaticFunctionCall(node2.init, filter);
+      if (functionCallMeta && node2?.id.type === "Identifier") {
+        parsed.push({
+          factoryName: functionCallMeta.name,
+          factoryNode: functionCallMeta.node,
+          functionName: node2.id.name,
+          namespace: functionCallMeta.namespace
+        });
+      }
+    };
+    const parsed = [];
+    if (node.declaration?.type === "VariableDeclaration") {
+      for (const d of node.declaration.declarations) {
+        processVariableDeclarator(d);
+      }
+    } else if (node.specifiers.length) {
+      for (const specifier of node.specifiers) {
+        if (specifier.type !== "ExportSpecifier" || specifier.exported.type !== "Identifier" || specifier.local.type !== "Identifier") {
+          continue;
+        }
+        const declaration = scopeTracker.getDeclaration(specifier.local.name);
+        if (declaration?.type !== "Variable") {
+          continue;
+        }
+        for (const d of declaration.variableNode.declarations) {
+          processVariableDeclarator(d);
+        }
+      }
+    }
+    return parsed;
+  }
+  if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "CallExpression") {
+    const functionCallMeta = parseStaticFunctionCall(node.declaration, filter);
+    if (functionCallMeta) {
+      return [{
+        factoryName: functionCallMeta.name,
+        factoryNode: functionCallMeta.node,
+        functionName: "default",
+        namespace: functionCallMeta.namespace
+      }];
+    }
+    return [];
+  }
+  return [];
+}
+function createFactoryProcessor(filePath, scopeTracker, namesToFactoryMeta, imports, autoImportsToSources, alias) {
+  const { directImports, namespaces } = processImports(imports, alias);
+  const localFactoryNames = new Set(namesToFactoryMeta.keys());
+  for (const [localName, directImport] of directImports) {
+    if (namesToFactoryMeta.has(directImport.originalName)) {
+      localFactoryNames.add(localName);
+    }
+  }
+  const LOCAL_FACTORY_NAMES_RE = new RegExp(`\\b(${[...localFactoryNames].map((f) => escapeRE(f)).join("|")})\\b`);
+  function _resolvePath(path) {
+    let p = path;
+    if (isAbsolute(p)) {
+      return p;
+    }
+    p = resolveAlias$1(p, alias);
+    if (isAbsolute(p)) {
+      return p;
+    }
+    return join(parse$1(filePath).dir, p);
+  }
+  function getFactoryByLocalName(localName) {
+    if (!localName) {
+      return void 0;
+    }
+    const directImport = directImports.get(localName);
+    if (directImport) {
+      return namesToFactoryMeta.get(directImport.originalName);
+    }
+    return namesToFactoryMeta.get(localName);
+  }
+  function processFactory(walkContext, node, handler) {
+    const parsedFactoryCalls = parseKeyedFunctionFactory(node, LOCAL_FACTORY_NAMES_RE, scopeTracker);
+    if (!parsedFactoryCalls.length) {
+      return;
+    }
+    for (const parsedFactoryCall of parsedFactoryCalls) {
+      let isFactoryImport = function(node2) {
+        return node2?.type === "Import" && node2.importNode.importKind !== "type";
+      };
+      const factoryMeta = getFactoryByLocalName(parsedFactoryCall.factoryName);
+      if (!factoryMeta) {
+        logger.error(`[nuxt:compiler] No factory function found for \`${parsedFactoryCall.functionName}\` in file \`${filePath}\`. This is a Nuxt bug.`);
+        continue;
+      }
+      const scopeTrackerNode = scopeTracker.getDeclaration(!parsedFactoryCall.namespace ? parsedFactoryCall.factoryName : parsedFactoryCall.namespace);
+      let importSourceResolved;
+      if (isFactoryImport(scopeTrackerNode)) {
+        importSourceResolved = stripExtension(_resolvePath(scopeTrackerNode.importNode.source.value));
+      } else if (!scopeTrackerNode) {
+        const autoImportedSource = autoImportsToSources?.get(factoryMeta.name);
+        if (autoImportedSource) {
+          importSourceResolved = stripExtension(_resolvePath(autoImportedSource));
+        }
+      }
+      if (!importSourceResolved) {
+        continue;
+      }
+      const resolvedFactorySource = factoryMeta.source;
+      if (!parsedFactoryCall.namespace && // and the factory is imported directly
+      (isFactoryImport(scopeTrackerNode) && // import { createUseFetch } from '...'
+      (scopeTrackerNode.node.type === "ImportSpecifier" && scopeTrackerNode.node.importKind !== "type" || scopeTrackerNode.node.type === "ImportDefaultSpecifier" && factoryMeta.name === "default") && importSourceResolved === resolvedFactorySource || !scopeTrackerNode && importSourceResolved === resolvedFactorySource)) {
+        handler({ parseFactoryResult: parsedFactoryCall, factory: factoryMeta });
+        walkContext.skip();
+        continue;
+      }
+      if (parsedFactoryCall.namespace) {
+        const namespacedImportMeta = namespaces.get(resolvedFactorySource);
+        const namespaceScopeTrackerNode = scopeTracker.getDeclaration(parsedFactoryCall.namespace);
+        if (namespacedImportMeta && namespacedImportMeta.namespaces.has(parsedFactoryCall.namespace) && namespaceScopeTrackerNode?.type === "Import" && namespaceScopeTrackerNode.node.type === "ImportNamespaceSpecifier") {
+          handler({ parseFactoryResult: parsedFactoryCall, factory: factoryMeta });
+        }
+        walkContext.skip();
+        continue;
+      }
+      logger.debug(`[nuxt:compiler] The factory function \`${factoryMeta.name}\` used to create \`${parsedFactoryCall.functionName}\` in file \`${filePath}\` is not imported and is not in auto-imports. Skipping processing.`);
+    }
+  }
+  return {
+    processFactory
+  };
+}
+function scanFileForFactories(id, code, namesToFactoryMeta, autoImportsToSources, alias) {
+  const results = [];
+  const context = createScanPluginContext(code, id);
+  const scopeTracker = new ScopeTracker({
+    preserveExitedScopes: true
+  });
+  const { processFactory } = createFactoryProcessor(id, scopeTracker, namesToFactoryMeta, context.getParsedStaticImports(), autoImportsToSources, alias);
+  context.walkParsed({
+    scopeTracker
+  });
+  scopeTracker.freeze();
+  let isWalkingSupportedSubtree = false;
+  context.walkParsed({
+    scopeTracker,
+    enter(node) {
+      if (node.type !== "Program" && !isWalkingSupportedSubtree && node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration" && node.type !== "ImportDeclaration") {
+        this.skip();
+      }
+      if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
+        return;
+      }
+      isWalkingSupportedSubtree = true;
+      processFactory(this, node, ({ parseFactoryResult, factory }) => {
+        results.push({
+          name: parseFactoryResult.functionName,
+          source: id,
+          argumentLength: factory.argumentLength
+        });
+      });
+    },
+    leave(node) {
+      if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ImportDeclaration") {
+        isWalkingSupportedSubtree = false;
+      }
+    }
+  });
+  return results;
+}
+const KeyedFunctionFactoriesScanPlugin = (options) => {
+  const fileResults = /* @__PURE__ */ new Map();
+  const namesToFactoryMeta = new Map(options.factories.map((f) => [f.name, {
+    ...f,
+    source: stripExtension(resolveAlias$1(f.source, options.alias))
+  }]));
+  const KEYED_FUNCTION_FACTORY_NAMES_RE = new RegExp(`\\b(${options.factories.map((f) => escapeRE(f.name)).join("|")})\\b`);
+  const result = {
+    fileResults,
+    factoryNamesRegex: KEYED_FUNCTION_FACTORY_NAMES_RE,
+    namesToFactoryMeta
+  };
+  return {
+    result,
+    name: "nuxt:keyed-function-factories",
+    filter: {
+      id: { include: JS_EXT_RE },
+      code: { include: KEYED_FUNCTION_FACTORY_NAMES_RE }
+    },
+    scan({ id, autoImportsToSources }) {
+      const results = [];
+      const scopeTracker = new ScopeTracker({
+        preserveExitedScopes: true
+      });
+      const { processFactory } = createFactoryProcessor(id, scopeTracker, namesToFactoryMeta, this.getParsedStaticImports(), autoImportsToSources, options.alias);
+      this.walkParsed({
+        scopeTracker
+      });
+      scopeTracker.freeze();
+      let isWalkingSupportedSubtree = false;
+      this.walkParsed({
+        scopeTracker,
+        enter(node) {
+          if (node.type !== "Program" && !isWalkingSupportedSubtree && node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration" && node.type !== "ImportDeclaration") {
+            this.skip();
+          }
+          if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
+            return;
+          }
+          isWalkingSupportedSubtree = true;
+          processFactory(this, node, ({ parseFactoryResult, factory }) => {
+            results.push({
+              name: parseFactoryResult.functionName,
+              source: id,
+              argumentLength: factory.argumentLength
+            });
+          });
+        },
+        leave(node) {
+          if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ImportDeclaration") {
+            isWalkingSupportedSubtree = false;
+          }
+        }
+      });
+      fileResults.set(id, results);
+    },
+    afterScan: (nuxt) => {
+      for (const functions of fileResults.values()) {
+        nuxt.options.optimization.keyedComposables.push(...functions);
+      }
+    }
+  };
+};
+const KeyedFunctionFactoriesPlugin = (options) => createUnplugin(() => {
+  const namesToFactoryMeta = new Map(options.factories.map((f) => [f.name, {
+    ...f,
+    source: stripExtension(resolveAlias$1(f.source, options.alias))
+  }]));
+  const KEYED_FUNCTION_FACTORY_NAMES_RE = new RegExp(`\\b(${options.factories.map((f) => escapeRE(f.name)).join("|")})\\b`);
+  return {
+    name: "nuxt:compiler:keyed-function-factories",
+    enforce: "post",
+    transform: {
+      filter: {
+        id: {
+          include: JS_EXT_RE,
+          exclude: [NUXT_LIB_RE, STYLE_QUERY_RE$1, MACRO_QUERY_RE$2]
+        },
+        code: { include: KEYED_FUNCTION_FACTORY_NAMES_RE }
+      },
+      async handler(code, id) {
+        const s = new MagicString(code);
+        const scopeTracker = new ScopeTracker({
+          preserveExitedScopes: true
+        });
+        const autoImports = await options.getAutoImports();
+        const autoImportsToSources = new Map(autoImports.map((i) => [i.as || i.name, i.from]));
+        const { processFactory } = createFactoryProcessor(
+          id,
+          scopeTracker,
+          namesToFactoryMeta,
+          findStaticImports(code).map((i) => parseStaticImport(i)),
+          autoImportsToSources,
+          options.alias
+        );
+        function rewriteFactoryMacro(node) {
+          if (node.type === "Identifier") {
+            if (code[node.end] === "?" && code[node.end + 1] === ".") {
+              s.overwrite(
+                node.start,
+                node.end + 2,
+                `${node.name}?.__nuxt_factory`
+              );
+            } else {
+              s.overwrite(
+                node.start,
+                node.end,
+                `${node.name}.__nuxt_factory`
+              );
+            }
+          } else if (code[node.end] === "?" && code[node.end + 1] === ".") {
+            s.appendLeft(node.end + 2, "__nuxt_factory");
+          } else {
+            s.appendLeft(node.end, ".__nuxt_factory");
+          }
+        }
+        const { program } = parseAndWalk(code, id, {
+          scopeTracker
+        });
+        scopeTracker.freeze();
+        walk(program, {
+          // no need for a scope tracker pre-pass, since we only care about imports
+          // and we only consider the root scope (because that's where an export would be - so no shadowing)
+          scopeTracker,
+          enter(node) {
+            if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
+              return;
+            }
+            processFactory(this, node, ({ parseFactoryResult }) => {
+              rewriteFactoryMacro(parseFactoryResult.factoryNode);
+            });
+          }
+        });
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
+          };
+        }
+      }
+    }
+  };
+});
+
+const stringTypes = ["Literal", "TemplateLiteral"];
+const SUPPORTED_EXT_RE$1 = /^[^?]*\.(?:m?[jt]sx?|vue)(?:$|\?)/;
+const SCRIPT_RE$1 = /(?<=<script[^>]*>)[\s\S]*?(?=<\/script>)/i;
+const NUXT_INJECTED_MARKER = "/* nuxt-injected */";
+function buildKeyedFunctionsState(keyedFunctions) {
+  const namesToSourcesToFunctionMeta = /* @__PURE__ */ new Map();
+  const defaultExportSources = /* @__PURE__ */ new Set();
+  for (const f of keyedFunctions) {
+    let functionName = f.name;
+    const fnSource = typeof f.source === "string" ? stripExtension(f.source) : "";
+    if (f.name === "default") {
+      const parsedSource = parse$1(f.source);
+      defaultExportSources.add(parsedSource.name);
+      functionName = camelCase(parsedSource.name);
+    }
+    if (import.meta.dev) {
+      const sourcesToFunctionMeta2 = namesToSourcesToFunctionMeta.get(functionName);
+      const existingEntry = sourcesToFunctionMeta2?.get(fnSource);
+      if (existingEntry?.source && existingEntry.source === fnSource) {
+        logger.warn(`[nuxt:compiler] [keyed-functions] Duplicate function name \`${functionName}\`${functionName !== f.name ? ` defined as \`${f.name}\`` : ""} with ${f.source ? `the same source \`${f.source}\`` : "no source"} found. Overwriting the existing entry.`);
+      }
+    }
+    let sourcesToFunctionMeta = namesToSourcesToFunctionMeta.get(functionName);
+    if (!sourcesToFunctionMeta) {
+      sourcesToFunctionMeta = /* @__PURE__ */ new Map();
+      namesToSourcesToFunctionMeta.set(functionName, sourcesToFunctionMeta);
+    }
+    sourcesToFunctionMeta.set(fnSource, {
+      ...f,
+      // TODO: use only `fnSource` in Nuxt 5
+      source: typeof f.source === "string" ? fnSource : f.source
+    });
+  }
+  const sources = /* @__PURE__ */ new Set();
+  for (const sourcesToFunctionMeta of namesToSourcesToFunctionMeta.values()) {
+    for (const f of sourcesToFunctionMeta.values()) {
+      if (f.source && typeof f.source === "string") {
+        sources.add(f.source);
+      }
+    }
+  }
+  const codeIncludeRE = new RegExp(`\\b(${[...namesToSourcesToFunctionMeta.keys(), ...defaultExportSources].map((f) => escapeRE(f)).join("|")})\\b`);
+  return { namesToSourcesToFunctionMeta, defaultExportSources, sources, codeIncludeRE };
+}
+const KeyedFunctionsPlugin = (options) => createUnplugin(() => {
+  let state = buildKeyedFunctionsState(options.keyedFunctions);
+  let lastKeyedFunctionsLength = options.keyedFunctions.length;
+  function getState() {
+    if (options.dev && options.getKeyedFunctions) {
+      const current = options.getKeyedFunctions();
+      if (current.length !== lastKeyedFunctionsLength) {
+        state = buildKeyedFunctionsState(current);
+        lastKeyedFunctionsLength = current.length;
+      }
+    }
+    return state;
+  }
+  return {
+    name: "nuxt:compiler:keyed-functions",
+    enforce: "post",
+    transform: {
+      filter: {
+        id: {
+          include: SUPPORTED_EXT_RE$1,
+          exclude: [NUXT_LIB_RE, STYLE_QUERY_RE$1, MACRO_QUERY_RE$2]
+        },
+        // In dev mode, skip the static code filter to allow HMR-added composables to be processed.
+        // In production, use the static regex for performance.
+        ...!options.dev && { code: { include: state.codeIncludeRE } }
+      },
+      async handler(code, _id) {
+        const { namesToSourcesToFunctionMeta, sources } = getState();
+        if (options.dev) {
+          const { codeIncludeRE } = getState();
+          if (!codeIncludeRE.test(code)) {
+            return;
+          }
+        }
+        const { 0: script = code, index: codeIndex = 0 } = code.match(SCRIPT_RE$1) || { 0: code, index: 0 };
+        const id = stripExtension(_id);
+        const { directImports, namespaces } = processImports(findStaticImports(script).map((i) => parseStaticImport(i)), options.alias);
+        const shouldConsiderExports = sources.has(id);
+        const localNamesToExportedName = /* @__PURE__ */ new Map();
+        const possibleLocalFunctionNames = new Set(namesToSourcesToFunctionMeta.keys());
+        for (const [localName, directImport] of directImports) {
+          const functionName = directImport.originalName === "default" ? camelCase(parse$1(directImport.source).name) : directImport.originalName;
+          if (namesToSourcesToFunctionMeta.has(functionName)) {
+            possibleLocalFunctionNames.add(localName);
+          }
+        }
+        const autoImports = await options.getAutoImports();
+        const autoImportsToSources = new Map(autoImports.map((i) => [i.as || i.name, i.from]));
+        function getFunctionMetaByLocalName(localName, source) {
+          if (!localName) {
+            return;
+          }
+          const exportedName = localNamesToExportedName.get(localName);
+          if (exportedName) {
+            return namesToSourcesToFunctionMeta.get(exportedName)?.get(source);
+          }
+          const directImport = directImports.get(localName);
+          if (directImport) {
+            const functionName = directImport.originalName === "default" ? camelCase(parse$1(directImport.source).name) : directImport.originalName;
+            const sourcesToMetas = namesToSourcesToFunctionMeta.get(functionName);
+            if (!sourcesToMetas) {
+              return;
+            }
+            const fnMeta = sourcesToMetas.get(source);
+            if (fnMeta) {
+              return fnMeta;
+            }
+            if (source.startsWith(options.appDir)) {
+              for (const [fnSource, meta] of sourcesToMetas) {
+                if (meta.name !== functionName || !fnSource.startsWith(options.appDir)) {
+                  continue;
+                }
+                return meta;
+              }
+            }
+            const backwardsCompatibleFnMeta = sourcesToMetas.get("");
+            if (backwardsCompatibleFnMeta?.source === void 0) {
+              const autoImportResolvedSource = stripExtension(resolveAlias$1(autoImportsToSources.get(localName) ?? ""));
+              if (autoImportResolvedSource === source) {
+                return backwardsCompatibleFnMeta;
+              }
+            } else if (backwardsCompatibleFnMeta.source instanceof RegExp && backwardsCompatibleFnMeta.source.test(source)) {
+              return backwardsCompatibleFnMeta;
+            }
+            return;
+          }
+          return namesToSourcesToFunctionMeta.get(localName)?.get(source);
+        }
+        function _resolvePath(path) {
+          let p = path;
+          if (isAbsolute(p)) {
+            return p;
+          }
+          p = resolveAlias$1(p, options.alias);
+          if (isAbsolute(p)) {
+            return p;
+          }
+          return join(parse$1(id).dir, p);
+        }
+        const s = new MagicString(code);
+        let count = 0;
+        const scopeTracker = new ScopeTracker({
+          preserveExitedScopes: true
+        });
+        const { program } = parseAndWalk(code, _id, {
+          scopeTracker,
+          enter(node) {
+            if (!shouldConsiderExports) {
+              return;
+            }
+            if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
+              return;
+            }
+            const result = parseStaticExportIdentifiers(node);
+            for (const exportMeta of result) {
+              const { localName, exportedName } = exportMeta;
+              const functionName = exportedName === "default" ? camelCase(parse$1(id).name) : getFunctionMetaByLocalName(exportedName, id)?.name;
+              if (!functionName) {
+                continue;
+              }
+              localNamesToExportedName.set(localName, functionName);
+            }
+          }
+        });
+        scopeTracker.freeze();
+        for (const localName of localNamesToExportedName.keys()) {
+          possibleLocalFunctionNames.add(localName);
+        }
+        const LOCAL_FUNCTION_NAMES_RE = new RegExp(`\\b(${[...possibleLocalFunctionNames].map((f) => escapeRE(f)).join("|")})\\b`);
+        function processKeyedFunction(walkContext, node, handler) {
+          if (node.type !== "CallExpression" && node.type !== "ChainExpression") {
+            return;
+          }
+          const parsedCall = parseStaticFunctionCall(node, LOCAL_FUNCTION_NAMES_RE);
+          if (!parsedCall) {
+            return;
+          }
+          const functionScopeTrackerNode = scopeTracker.getDeclaration(!parsedCall.namespace ? parsedCall.name : parsedCall.namespace);
+          function isKeyedFunctionImport(node2) {
+            return node2?.type === "Import" && node2.importNode.importKind !== "type";
+          }
+          let importSourceResolved;
+          if (localNamesToExportedName.has(parsedCall.name) && functionScopeTrackerNode?.scope === "") {
+            importSourceResolved = id;
+          } else if (isKeyedFunctionImport(functionScopeTrackerNode)) {
+            importSourceResolved = stripExtension(_resolvePath(functionScopeTrackerNode.importNode.source.value));
+          }
+          if (!importSourceResolved) {
+            walkContext.skip();
+            return;
+          }
+          const fnMeta = getFunctionMetaByLocalName(parsedCall.name, importSourceResolved);
+          if (!fnMeta) {
+            walkContext.skip();
+            return;
+          }
+          if (!parsedCall.namespace) {
+            if (parsedCall.callExpression.arguments.length >= fnMeta.argumentLength && !parsedCall.callExpression.arguments.some((a) => a.type === "SpreadElement")) {
+              walkContext.skip();
+              return;
+            }
+            if (
+              // the function is imported
+              isKeyedFunctionImport(functionScopeTrackerNode) && // import { useKeyed } from '...'
+              (functionScopeTrackerNode.node.type === "ImportSpecifier" && functionScopeTrackerNode.node.importKind !== "type" || functionScopeTrackerNode.node.type === "ImportDefaultSpecifier" && fnMeta.name === "default") && // the function is imported from the correct source when `source` is specified
+              (typeof fnMeta.source === "string" && stripExtension(fnMeta.source) === importSourceResolved || !fnMeta.source && stripExtension(_resolvePath(autoImportsToSources.get(parsedCall.name) ?? "")) === importSourceResolved || fnMeta.source instanceof RegExp && fnMeta.source.test(importSourceResolved) || typeof fnMeta.source === "string" && fnMeta.source.startsWith(options.appDir)) || localNamesToExportedName.has(parsedCall.name) && functionScopeTrackerNode?.scope === ""
+            ) {
+              handler({ parsedCall, fnMeta });
+            }
+            walkContext.skip();
+            return;
+          }
+          if (parsedCall.namespace) {
+            const namespacedImportMeta = namespaces.get(importSourceResolved);
+            const namespaceScopeTrackerNode = scopeTracker.getDeclaration(parsedCall.namespace);
+            if (namespacedImportMeta && namespacedImportMeta.namespaces.has(parsedCall.namespace) && namespaceScopeTrackerNode?.type === "Import" && namespaceScopeTrackerNode.node.type === "ImportNamespaceSpecifier") {
+              handler({ parsedCall, fnMeta });
+            }
+            walkContext.skip();
+            return;
+          }
+        }
+        walk(program, {
+          scopeTracker,
+          enter(node) {
+            processKeyedFunction(this, node, ({ parsedCall, fnMeta }) => {
+              const lastArgument = parsedCall.callExpression.arguments[parsedCall.callExpression.arguments.length - 1];
+              if (lastArgument?.type === "Literal" && typeof lastArgument.value === "string" && lastArgument.end + NUXT_INJECTED_MARKER.length + 1 < parsedCall.callExpression.end) {
+                let wasKeyInjected = true;
+                for (let i2 = 0; i2 < NUXT_INJECTED_MARKER.length; i2++) {
+                  if (code[codeIndex + lastArgument.end + 1 + i2] !== NUXT_INJECTED_MARKER[i2]) {
+                    wasKeyInjected = false;
+                    break;
+                  }
+                }
+                if (wasKeyInjected) {
+                  return;
+                }
+              }
+              switch (parsedCall.name) {
+                case "useState":
+                  if (stringTypes.includes(parsedCall.callExpression.arguments[0]?.type) && typeof fnMeta.source === "string" && stripExtension(fnMeta.source) === stripExtension(resolveAlias$1("#app/composables/state", options.alias))) {
+                    return;
+                  }
+                  break;
+                case "useFetch":
+                case "useLazyFetch":
+                  if (stringTypes.includes(parsedCall.callExpression.arguments[1]?.type) && typeof fnMeta.source === "string" && stripExtension(fnMeta.source) === stripExtension(resolveAlias$1("#app/composables/fetch", options.alias))) {
+                    return;
+                  }
+                  break;
+                case "useAsyncData":
+                case "useLazyAsyncData":
+                  if (stringTypes.includes(parsedCall.callExpression.arguments[0]?.type) && typeof fnMeta.source === "string" && stripExtension(fnMeta.source) === stripExtension(resolveAlias$1("#app/composables/asyncData", options.alias))) {
+                    return;
+                  }
+                  break;
+              }
+              let i = codeIndex + parsedCall.callExpression.end - 2;
+              while (i >= codeIndex + parsedCall.callExpression.start && isWhitespace(code[i])) {
+                i--;
+              }
+              const endsWithComma = code[i] === ",";
+              s.appendLeft(
+                codeIndex + parsedCall.callExpression.end - 1,
+                (parsedCall.callExpression.arguments.length && !endsWithComma ? ", " : "") + "'$" + hash(`${_id}-${++count}`).slice(0, 10) + `' ${NUXT_INJECTED_MARKER}`
+              );
+            });
+          }
+        });
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
+          };
+        }
+      }
+    }
+  };
+});
+
+const compilerModule = defineNuxtModule({
+  meta: {
+    name: "nuxt:compiler",
+    configKey: "compiler"
+  },
+  defaults: {
+    scan: true
+  },
+  setup(_options, nuxt) {
+    let unimport;
+    nuxt.hook("imports:context", (ctx) => {
+      unimport = ctx;
+    });
+    let scanResult;
+    let scanDirPaths = [];
+    let normalizedKeyedFunctions = [];
+    nuxt.hook("build:before", async () => {
+      addBuildPlugin(KeyedFunctionFactoriesPlugin({
+        sourcemap: !!nuxt.options.sourcemap.server || !!nuxt.options.sourcemap.client,
+        factories: nuxt.options.optimization.keyedComposableFactories,
+        alias: nuxt.options.alias,
+        getAutoImports: () => unimport?.getImports() || Promise.resolve([])
+      }));
+      if (_options.scan) {
+        const scanPlugin = KeyedFunctionFactoriesScanPlugin({
+          factories: nuxt.options.optimization.keyedComposableFactories,
+          alias: nuxt.options.alias
+        });
+        scanResult = scanPlugin.result;
+        await runScanPlugins([scanPlugin]);
+      }
+      normalizedKeyedFunctions = await Promise.all(nuxt.options.optimization.keyedComposables.map(async ({ source, ...rest }) => ({
+        ...rest,
+        source: typeof source === "string" ? await resolvePath(source, { fallbackToOriginal: true }) : source
+      })));
+      addBuildPlugin(KeyedFunctionsPlugin({
+        sourcemap: !!nuxt.options.sourcemap.server || !!nuxt.options.sourcemap.client,
+        keyedFunctions: normalizedKeyedFunctions,
+        getKeyedFunctions: () => normalizedKeyedFunctions,
+        alias: nuxt.options.alias,
+        getAutoImports: () => unimport?.getImports() || Promise.resolve([]),
+        appDir: nuxt.options.appDir,
+        dev: nuxt.options.dev
+      }));
+    });
+    async function runScanPlugins(plugins) {
+      const autoImports = await unimport?.getImports() || [];
+      const autoImportsToSources = new Map(autoImports.map((i) => [i.as || i.name, i.from]));
+      const dirPaths = /* @__PURE__ */ new Set();
+      const scanDirs = [];
+      for (const layer of nuxt.options._layers) {
+        if (layer.config?.compiler?.scan === false) {
+          continue;
+        }
+        const composablesDir = resolve(layer.config.srcDir, "composables");
+        if (!isDirectorySync(composablesDir) || dirPaths.has(composablesDir)) {
+          continue;
+        }
+        dirPaths.add(composablesDir);
+        const extensions = nuxt.options.extensions.map((e) => normalizeExtension(e));
+        scanDirs.push({
+          path: composablesDir,
+          extensions,
+          pattern: `**/*.{${extensions.join(",")}}`,
+          ignore: [`**/*.{${DECLARATION_EXTENSIONS.join(",")}}`]
+        });
+      }
+      scanDirPaths = scanDirs.map((d) => d.path);
+      const _filePaths = [];
+      await Promise.all(scanDirs.map(async (dir) => {
+        const files = await resolveFiles(dir.path, dir.pattern, { ignore: dir.ignore });
+        _filePaths.push(...files);
+      }));
+      const filePaths = await Promise.all(_filePaths.map((filePath) => resolvePath(filePath)));
+      for (const filePath of filePaths) {
+        const isFileWantedByPlugin = plugins.some((p) => {
+          if (!p.filter?.id) {
+            return true;
+          }
+          return matchFilter(filePath, p.filter.id);
+        });
+        if (!isFileWantedByPlugin) {
+          continue;
+        }
+        try {
+          const contents = await readFile(filePath, "utf-8");
+          const pluginScanThisContext = createScanPluginContext(contents, filePath);
+          await Promise.all(plugins.map(async (plugin) => {
+            if (plugin.filter?.id && !matchFilter(filePath, plugin.filter.id)) {
+              return;
+            }
+            if (plugin.filter?.code && !matchFilter(contents, plugin.filter.code)) {
+              return;
+            }
+            try {
+              await plugin.scan.call(pluginScanThisContext, { id: filePath, code: contents, nuxt, autoImportsToSources });
+            } catch (e) {
+              logger.error(`[nuxt:compiler] Plugin \`${plugin.name}\` failed to scan file \`${filePath}\``, e);
+            }
+          }));
+        } catch (e) {
+          logger.error(`[nuxt:compiler] Cannot read file \`${filePath}\``, e);
+        }
+      }
+      await Promise.all(plugins.map(async (plugin) => {
+        if (!plugin.afterScan) {
+          return;
+        }
+        try {
+          await plugin.afterScan(nuxt);
+        } catch (e) {
+          logger.error(`[nuxt:compiler] Error in \`afterScan\` hook of plugin \`${plugin.name}\``, e);
+        }
+      }));
+    }
+    if (nuxt.options.dev && _options.scan) {
+      nuxt.hook("builder:watch", async (event, relativePath) => {
+        if (!scanResult || !["add", "change", "unlink"].includes(event)) {
+          return;
+        }
+        const absolutePath = resolve(nuxt.options.srcDir, relativePath);
+        const isInScanDir = scanDirPaths.some((dir) => absolutePath === dir || absolutePath.startsWith(dir + "/"));
+        if (!isInScanDir) {
+          return;
+        }
+        const { fileResults, factoryNamesRegex, namesToFactoryMeta } = scanResult;
+        const oldEntries = fileResults.get(absolutePath);
+        if (oldEntries?.length) {
+          const resolvedSource = await resolvePath(absolutePath, { fallbackToOriginal: true });
+          for (let i = normalizedKeyedFunctions.length - 1; i >= 0; i--) {
+            if (normalizedKeyedFunctions[i].source === resolvedSource) {
+              normalizedKeyedFunctions.splice(i, 1);
+            }
+          }
+          fileResults.delete(absolutePath);
+        }
+        if (event === "unlink") {
+          return;
+        }
+        let contents;
+        try {
+          contents = await readFile(absolutePath, "utf-8");
+        } catch {
+          return;
+        }
+        if (!factoryNamesRegex.test(contents)) {
+          return;
+        }
+        const autoImports = await unimport?.getImports() || [];
+        const autoImportsToSources = new Map(autoImports.map((i) => [i.as || i.name, i.from]));
+        const newEntries = scanFileForFactories(
+          absolutePath,
+          contents,
+          namesToFactoryMeta,
+          autoImportsToSources,
+          nuxt.options.alias
+        );
+        if (newEntries.length) {
+          fileResults.set(absolutePath, newEntries);
+          const normalized = await Promise.all(newEntries.map(async ({ source, ...rest }) => ({
+            ...rest,
+            source: typeof source === "string" ? await resolvePath(source, { fallbackToOriginal: true }) : source
+          })));
+          normalizedKeyedFunctions.push(...normalized);
+        }
+      });
+    }
+  }
+});
+function matchFilter(input, filter) {
+  if (typeof filter === "function") {
+    return filter(input);
+  }
+  const include = filter.include ? toArray(filter.include).some((v) => matchWithStringOrRegex(input, v)) : true;
+  const exclude = filter.exclude ? toArray(filter.exclude).some((v) => matchWithStringOrRegex(input, v)) : false;
+  return include && !exclude;
+}
+
+async function getVueHash(nuxt) {
+  const id = "vue";
+  const { hash: hash2 } = await getHashes(nuxt, {
+    id,
+    cwd: (layer) => layer.config.srcDir || layer.cwd,
+    patterns: (layer) => {
+      const srcDir = layer.config.srcDir || layer.cwd;
+      return [
+        "**",
+        `!${relative(srcDir, layer.config.serverDir || join(layer.cwd, "server"))}/**`,
+        `!${relative(srcDir, resolve$1(layer.cwd, layer.config.dir?.public || "public"))}/**`,
+        "!node_modules/**",
+        "!nuxt.config.*"
+      ];
+    },
+    configOverrides: {
+      buildId: void 0,
+      serverDir: void 0,
+      nitro: void 0,
+      devServer: void 0,
+      runtimeConfig: void 0,
+      logLevel: void 0,
+      devServerHandlers: void 0,
+      devtools: void 0
+    }
+  });
+  const cacheFile = join(getCacheDir(nuxt), id, hash2 + ".tar");
+  const buildIdCacheFile = cacheFile.replace(".tar", ".buildid");
+  return {
+    hash: hash2,
+    async collectCache() {
+      const start = Date.now();
+      await writeCache(nuxt.options.buildDir, nuxt.options.buildDir, cacheFile);
+      await mkdir(dirname(buildIdCacheFile), { recursive: true });
+      await writeFile(buildIdCacheFile, nuxt.options.buildId);
+      const elapsed = Date.now() - start;
+      consola.success(`Cached Vue client and server builds in \`${elapsed}ms\`.`);
+    },
+    async restoreCache() {
+      const start = Date.now();
+      const res = await restoreCacheFromFile(nuxt.options.buildDir, cacheFile);
+      const elapsed = Date.now() - start;
+      if (res) {
+        consola.success(`Restored Vue client and server builds from cache in \`${elapsed}ms\`.`);
+      }
+      return res;
+    }
+  };
+}
+async function restoreCachedBuildId(nuxt) {
+  const { hash: hash2 } = await getVueHash(nuxt);
+  const cacheDir = getCacheDir(nuxt);
+  const buildIdCacheFile = join(cacheDir, "vue", hash2 + ".buildid");
+  if (!existsSync(buildIdCacheFile)) {
+    return;
+  }
+  const cachedBuildId = (await readFile(buildIdCacheFile, "utf-8")).trim();
+  if (!cachedBuildId || !/^[\w-]+$/.test(cachedBuildId)) {
+    return;
+  }
+  nuxt.options.buildId = cachedBuildId;
+  nuxt.options.runtimeConfig.app.buildId = cachedBuildId;
+  consola.debug(`Restored cached buildId: ${cachedBuildId}`);
+}
+async function cleanupCaches(nuxt) {
+  const start = Date.now();
+  const caches = await glob(["*/*.tar", "*/*.buildid"], {
+    cwd: getCacheDir(nuxt),
+    absolute: true
+  });
+  if (caches.length >= 10) {
+    const cachesWithMeta = await Promise.all(caches.map(async (cache) => {
+      return [cache, await stat(cache).then((r) => r.mtime.getTime()).catch(() => 0)];
+    }));
+    cachesWithMeta.sort((a, b) => a[1] - b[1]);
+    for (const [cache] of cachesWithMeta.slice(0, cachesWithMeta.length - 10)) {
+      await unlink(cache);
+    }
+    const elapsed = Date.now() - start;
+    consola.success(`Cleaned up old build caches in \`${elapsed}ms\`.`);
+  }
+}
+async function getHashes(nuxt, options) {
+  if (nuxt[`_${options.id}BuildHash`]) {
+    return nuxt[`_${options.id}BuildHash`];
+  }
+  const start = Date.now();
+  const hashSources = [];
+  let layerCtr = 0;
+  for (const layer of nuxt.options._layers) {
+    if (layer.cwd.includes("node_modules")) {
+      continue;
+    }
+    const layerName = `layer#${layerCtr++}`;
+    hashSources.push({
+      name: `${layerName}:config`,
+      data: serialize({
+        ...layer.config,
+        ...options.configOverrides || {}
+      })
+    });
+    const normalizeFiles = (files) => files.map((f) => ({
+      name: f.name,
+      size: f.attrs?.size,
+      data: hash(f.data)
+    })).sort((a, b) => a.name.localeCompare(b.name));
+    const isIgnored = createIsIgnored(nuxt);
+    const sourceFiles = await readFilesRecursive(options.cwd(layer), {
+      shouldIgnore: isIgnored,
+      // TODO: Validate if works with absolute paths
+      cwd: nuxt.options.rootDir,
+      patterns: options.patterns(layer)
+    });
+    hashSources.push({
+      name: `${layerName}:src`,
+      data: normalizeFiles(sourceFiles)
+    });
+    const rootFiles = await readFilesRecursive(layer.config?.rootDir || layer.cwd, {
+      shouldIgnore: isIgnored,
+      // TODO: Validate if works with absolute paths
+      cwd: nuxt.options.rootDir,
+      patterns: [
+        ".nuxtrc",
+        ".npmrc",
+        "package.json",
+        "package-lock.json",
+        "yarn.lock",
+        "pnpm-lock.yaml",
+        "tsconfig.json",
+        "bun.lock",
+        "bun.lockb"
+      ]
+    });
+    hashSources.push({
+      name: `${layerName}:root`,
+      data: normalizeFiles(rootFiles)
+    });
+  }
+  hashSources.sort((a, b) => a.name.localeCompare(b.name));
+  const res = nuxt[`_${options.id}BuildHash`] = {
+    hash: hash(hashSources),
+    sources: hashSources
+  };
+  const elapsed = Date.now() - start;
+  consola.debug(`Computed \`${options.id}\` build hash in \`${elapsed}ms\`.`);
+  return res;
+}
+async function readFilesRecursive(dir, opts) {
+  if (Array.isArray(dir)) {
+    return (await Promise.all(dir.map((d) => readFilesRecursive(d, opts)))).flat();
+  }
+  const files = await glob(opts.patterns, { cwd: dir });
+  const fileEntries = await Promise.all(files.map(async (fileName) => {
+    if (!opts.shouldIgnore?.(fileName)) {
+      const file = await readFileWithMeta(dir, fileName);
+      if (!file) {
+        return;
+      }
+      return {
+        ...file,
+        name: relative(opts.cwd, join(dir, file.name))
+      };
+    }
+  }));
+  return fileEntries.filter(Boolean);
+}
+async function readFileWithMeta(dir, fileName, count = 0) {
+  let fd = void 0;
+  try {
+    fd = await open(resolve$1(dir, fileName));
+    const stats = await fd.stat();
+    if (!stats?.isFile()) {
+      return;
+    }
+    const mtime = stats.mtime.getTime();
+    const data = await fd.readFile();
+    if ((await fd.stat()).mtime.getTime() !== mtime) {
+      await fd.close();
+      fd = void 0;
+      if (count < 5) {
+        return await readFileWithMeta(dir, fileName, count + 1);
+      }
+      console.warn(`Failed to read file \`${fileName}\` as it changed during read.`);
+      return;
+    }
+    return {
+      name: fileName,
+      data,
+      attrs: {
+        mtime,
+        size: stats.size
+      }
+    };
+  } catch (err) {
+    console.warn(`Failed to read file \`${fileName}\`:`, err);
+  } finally {
+    await fd?.close();
+  }
+}
+async function restoreCacheFromFile(cwd, cacheFile) {
+  if (!existsSync(cacheFile)) {
+    return false;
+  }
+  const resolvedCwd = resolve$1(cwd) + "/";
+  const files = parseTar(await readFile(cacheFile));
+  for (const file of files) {
+    let fd = void 0;
+    try {
+      const filePath = resolve$1(cwd, file.name);
+      if (!filePath.startsWith(resolvedCwd)) {
+        consola.warn(`Skipping unsafe cache path: ${file.name}`);
+        continue;
+      }
+      await mkdir(dirname(filePath), { recursive: true });
+      const existingStats = await stat(filePath).catch(() => null);
+      const cachedSize = file.data?.byteLength ?? 0;
+      if (existingStats?.isFile() && existingStats.size === cachedSize) {
+        const lastModified = Number.parseInt(file.attrs?.mtime?.toString().padEnd(13, "0") || "0");
+        if (existingStats.mtime.getTime() >= lastModified) {
+          consola.debug(`Skipping \`${file.name}\` (up to date or newer than cache)`);
+          continue;
+        }
+      }
+      fd = await open(filePath, "w");
+      await fd.writeFile(file.data);
+    } catch (err) {
+      console.error(err);
+    } finally {
+      await fd?.close();
+    }
+  }
+  return true;
+}
+async function writeCache(cwd, sources, cacheFile) {
+  const fileEntries = await readFilesRecursive(sources, {
+    patterns: ["**/*", "!analyze/**"],
+    cwd
+  });
+  const tarData = createTar(fileEntries);
+  await mkdir(dirname(cacheFile), { recursive: true });
+  await writeFile(cacheFile, tarData);
+}
+function getCacheDir(nuxt) {
+  let cacheDir = join(nuxt.options.workspaceDir, "node_modules");
+  if (!existsSync(cacheDir)) {
+    for (const dir of [...nuxt.options.modulesDir].sort((a, b) => a.length - b.length)) {
+      if (existsSync(dir)) {
+        cacheDir = dir;
+        break;
+      }
+    }
+  }
+  return join(cacheDir, ".cache/nuxt/builds");
+}
+
+const runtimeDependencies = [
+  // other deps
+  "devalue",
+  "klona",
+  // deliberate exports from nitro builder
+  "@nuxt/nitro-server/h3",
+  // unjs ecosystem
+  "defu",
+  "ufo",
+  "destr",
+  "consola",
+  "hookable",
+  "unctx",
+  "cookie-es",
+  "perfect-debounce",
+  "ohash",
+  "pathe",
+  "uncrypto"
+];
+
+const version = "4.4.2";
+const pkg = {
+	version: version};
+
+function createImportProtectionPatterns(nuxt, options) {
+  const patterns = [];
+  const context = contextFlags[options.context];
+  patterns.push([
+    /^(nuxt|nuxt3|nuxt-nightly)$/,
+    `\`nuxt\` or \`nuxt-nightly\` cannot be imported directly in ${context}.`,
+    options.context === "nuxt-app" ? ["Import runtime Nuxt composables from `#app` or `#imports` instead."] : ["Use `#app` or `#imports` for runtime composables in your Vue app code."]
+  ]);
+  patterns.push([
+    /^((~|~~|@|@@)?\/)?nuxt\.config(\.|$)/,
+    "Importing directly from a `nuxt.config` file is not allowed.",
+    ["Use `useRuntimeConfig()` to access runtime config in your app.", "Use `useAppConfig()` to access config that doesn't need to be changed at runtime.", "Use a Nuxt module to access build-time configuration."]
+  ]);
+  patterns.push([/(^|node_modules\/)@vue\/composition-api/]);
+  for (const mod of nuxt.options._installedModules) {
+    if (mod.entryPath) {
+      patterns.push([
+        new RegExp(`^${escapeRE(mod.entryPath)}$`),
+        "Importing directly from module entry-points is not allowed.",
+        ["Import from the module's runtime directory instead (e.g. `my-module/runtime/...`)."]
+      ]);
+    }
+  }
+  for (const i of [/(^|node_modules\/)@nuxt\/(cli|kit|test-utils)/, /(^|node_modules\/)nuxi/, /(^|node_modules\/)nitro(?:pack)?(?:-nightly)?(?:$|\/)(?!(?:dist\/)?(?:node_modules|presets|runtime|types))/, /(^|node_modules\/)nuxt\/(config|kit|schema)/]) {
+    patterns.push([
+      i,
+      `This module cannot be imported in ${context}.`,
+      ["These are build-time only packages and cannot be used at runtime."]
+    ]);
+  }
+  if (options.context === "nitro-app" || options.context === "shared") {
+    for (const i of ["#app", /^#build(\/|$)/]) {
+      patterns.push([
+        i,
+        `Vue app aliases are not allowed in ${context}.`,
+        ["Move this code to your Vue app directory or use a shared utility."]
+      ]);
+    }
+  }
+  if (options.context === "nuxt-app" || options.context === "shared") {
+    const serverRelative = escapeRE(relative(nuxt.options.rootDir, resolve(nuxt.options.srcDir, nuxt.options.serverDir || "server")));
+    patterns.push([
+      new RegExp("^" + serverRelative + "\\/(api|routes|middleware|plugins)\\/"),
+      `Importing from server is not allowed in ${context}.`,
+      ["Use `$fetch()` or `useFetch()` to fetch data from server routes.", "Move shared logic to the `shared/` directory."]
+    ]);
+    patterns.push([
+      /^#server(\/|$)/,
+      `Server aliases are not allowed in ${context}.`,
+      ["Use `$fetch()` or `useFetch()` to call server endpoints.", "Move shared logic to the `shared/` directory."]
+    ]);
+  }
+  return patterns;
+}
+const contextFlags = {
+  "nitro-app": "server runtime",
+  "nuxt-app": "the Vue part of your app",
+  "shared": "the #shared directory"
+};
+
+const TRANSFORM_MARKER = "/* _processed_nuxt_unctx_transform */\n";
+const TRANSFORM_MARKER_RE = /^\/\* _processed_nuxt_unctx_transform \*\/\n/;
+const UnctxTransformPlugin = (options) => createUnplugin(() => {
+  const transformer = createTransformer(options.transformerOptions);
+  return {
+    name: "unctx:transform",
+    enforce: "post",
+    transformInclude(id) {
+      return isVue(id, { type: ["template", "script"] }) || isJS(id);
+    },
+    transform: {
+      filter: {
+        ...transformer.filter,
+        code: {
+          ...transformer.filter.code,
+          exclude: TRANSFORM_MARKER_RE
+        }
+      },
+      handler(code) {
         if (!transformer.shouldTransform(code)) {
           return;
         }
@@ -4176,7 +5464,7 @@ const LayerAliasingPlugin = (options) => createUnplugin((_options, meta) => {
         filter: {
           id: ALIAS_ID_RE
         },
-        async handler(id, importer) {
+        handler(id, importer) {
           if (!importer) {
             return;
           }
@@ -4186,7 +5474,7 @@ const LayerAliasingPlugin = (options) => createUnplugin((_options, meta) => {
           }
           const resolvedId = resolveAlias$1(id, aliases[layer]);
           if (resolvedId !== id) {
-            return await this.resolve(resolvedId, importer, { skipSelf: true });
+            return this.resolve(resolvedId, importer, { skipSelf: true });
           }
         }
       }
@@ -4238,6 +5526,549 @@ async function loadServerBuilder(nuxt, builder = "@nuxt/nitro-server") {
   }
 }
 
+function getMemorySnapshot() {
+  const mem = process.memoryUsage();
+  return { rss: mem.rss, heapUsed: mem.heapUsed, heapTotal: mem.heapTotal };
+}
+function formatBytes(bytes) {
+  const abs = Math.abs(bytes);
+  if (abs < 1024) {
+    return `${bytes} B`;
+  }
+  if (abs < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDuration(ms) {
+  if (ms < 1) {
+    return `${Math.round(ms * 1e3)}\xB5s`;
+  }
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  return `${(ms / 6e4).toFixed(1)}min`;
+}
+const ANSI_RE = /\x1B\[[0-9;]*m/g;
+function pad(str, width, align = "left") {
+  const stripped = str.replace(ANSI_RE, "");
+  const diff = width - stripped.length;
+  if (diff <= 0) {
+    return str;
+  }
+  const padding = " ".repeat(diff);
+  return align === "right" ? padding + str : str + padding;
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+const SLOW_HOOK_THRESHOLD_MS = Number(process.env.NUXT_PERF_SLOW_HOOK_MS) || 50;
+const HOOK_PHASE_THRESHOLD_MS = 5;
+class NuxtPerfProfiler {
+  #phases = [];
+  #phaseStack = [];
+  #hookPhases = [];
+  #hookStartStack = [];
+  #modules = [];
+  #bundlerPluginTimings = /* @__PURE__ */ new Map();
+  #bundlerPluginSpans = [];
+  #globalStart;
+  #globalMemoryBefore;
+  #unsubscribe;
+  /** Offset to convert performance.now() (ms) to epoch microseconds for trace events */
+  #baseTs;
+  constructor(options) {
+    if (options?.startTime) {
+      this.#globalStart = performance.now() - (Date.now() - options.startTime);
+    } else {
+      this.#globalStart = performance.now();
+    }
+    this.#globalMemoryBefore = getMemorySnapshot();
+    this.#baseTs = Date.now() * 1e3 - this.#globalStart * 1e3;
+  }
+  installHookInterceptors(hooks) {
+    const unsubBefore = hooks.beforeEach((event) => {
+      this.#hookStartStack.push({
+        name: event.name,
+        time: performance.now(),
+        memory: getMemorySnapshot()
+      });
+    });
+    const unsubAfter = hooks.afterEach((event) => {
+      let startIdx = -1;
+      for (let i = this.#hookStartStack.length - 1; i >= 0; i--) {
+        if (this.#hookStartStack[i].name === event.name) {
+          startIdx = i;
+          break;
+        }
+      }
+      if (startIdx === -1) {
+        return;
+      }
+      const start = this.#hookStartStack.splice(startIdx, 1)[0];
+      const endTime = performance.now();
+      const memoryAfter = getMemorySnapshot();
+      const duration = round(endTime - start.time);
+      this.#hookPhases.push({
+        name: `hook:${event.name}`,
+        startTime: start.time,
+        endTime,
+        duration,
+        memoryBefore: start.memory,
+        memoryAfter,
+        memoryDelta: {
+          rss: memoryAfter.rss - start.memory.rss,
+          heapUsed: memoryAfter.heapUsed - start.memory.heapUsed
+        }
+      });
+    });
+    this.#unsubscribe = () => {
+      unsubBefore();
+      unsubAfter();
+    };
+  }
+  startPhase(name) {
+    this.#phaseStack.push({
+      name,
+      startTime: performance.now(),
+      memoryBefore: getMemorySnapshot()
+    });
+  }
+  endPhase(name) {
+    let phaseIdx = this.#phaseStack.length - 1;
+    if (name) {
+      phaseIdx = -1;
+      for (let i = this.#phaseStack.length - 1; i >= 0; i--) {
+        if (this.#phaseStack[i].name === name) {
+          phaseIdx = i;
+          break;
+        }
+      }
+      if (phaseIdx === -1) {
+        return;
+      }
+    }
+    if (phaseIdx < 0) {
+      return;
+    }
+    const open = this.#phaseStack.splice(phaseIdx, 1)[0];
+    const endTime = performance.now();
+    const memoryAfter = getMemorySnapshot();
+    this.#phases.push({
+      name: open.name,
+      startTime: open.startTime,
+      endTime,
+      duration: round(endTime - open.startTime),
+      memoryBefore: open.memoryBefore,
+      memoryAfter,
+      memoryDelta: {
+        rss: memoryAfter.rss - open.memoryBefore.rss,
+        heapUsed: memoryAfter.heapUsed - open.memoryBefore.heapUsed
+      }
+    });
+  }
+  recordBundlerPluginHook(pluginName, hookName, durationMs, startTime) {
+    let plugin = this.#bundlerPluginTimings.get(pluginName);
+    if (!plugin) {
+      plugin = /* @__PURE__ */ new Map();
+      this.#bundlerPluginTimings.set(pluginName, plugin);
+    }
+    const entry = plugin.get(hookName);
+    if (entry) {
+      entry.totalTime += durationMs;
+      entry.count++;
+      if (durationMs > entry.maxTime) {
+        entry.maxTime = durationMs;
+      }
+    } else {
+      plugin.set(hookName, { totalTime: durationMs, count: 1, maxTime: durationMs });
+    }
+    if (startTime != null && durationMs > 0.1) {
+      this.#bundlerPluginSpans.push({ pluginName, hookName, startTime, durationMs });
+    }
+  }
+  collectModuleTimings(installedModules) {
+    for (const mod of installedModules) {
+      const name = mod.meta?.name || "(anonymous)";
+      const setupTime = mod.timings?.setup;
+      if (setupTime != null) {
+        this.#modules.push({ name, setupTime });
+      }
+    }
+  }
+  getReport() {
+    const totalDuration = round(performance.now() - this.#globalStart);
+    const globalMemoryAfter = getMemorySnapshot();
+    const allPhases = [...this.#phases];
+    for (const hp of this.#hookPhases) {
+      if (hp.duration < HOOK_PHASE_THRESHOLD_MS) {
+        continue;
+      }
+      const hookName = hp.name.slice(5);
+      const alreadyCovered = this.#phases.some(
+        (p) => p.name === hookName && p.startTime <= hp.startTime && p.endTime >= hp.endTime
+      );
+      if (!alreadyCovered) {
+        allPhases.push({ ...hp, name: hookName });
+      }
+    }
+    allPhases.sort((a, b) => a.startTime - b.startTime);
+    function computeOwn(phase) {
+      const children = allPhases.filter(
+        (other) => other !== phase && other.startTime >= phase.startTime && other.endTime <= phase.endTime
+      );
+      const directChildren = children.filter(
+        (child) => !children.some(
+          (other) => other !== child && child.startTime >= other.startTime && child.endTime <= other.endTime
+        )
+      );
+      let childTime = 0;
+      let childRss = 0;
+      let childHeap = 0;
+      for (const child of directChildren) {
+        childTime += child.duration;
+        childRss += child.memoryDelta.rss;
+        childHeap += child.memoryDelta.heapUsed;
+      }
+      return {
+        ownDuration: round(Math.max(0, phase.duration - childTime)),
+        ownMemoryDelta: {
+          rss: phase.memoryDelta.rss - childRss,
+          heapUsed: phase.memoryDelta.heapUsed - childHeap
+        }
+      };
+    }
+    return {
+      totalDuration,
+      totalMemoryDelta: {
+        rss: globalMemoryAfter.rss - this.#globalMemoryBefore.rss,
+        heapUsed: globalMemoryAfter.heapUsed - this.#globalMemoryBefore.heapUsed
+      },
+      phases: allPhases.map((p) => {
+        const own = computeOwn(p);
+        return {
+          name: p.name,
+          duration: p.duration,
+          ownDuration: own.ownDuration,
+          memoryBefore: p.memoryBefore,
+          memoryAfter: p.memoryAfter,
+          memoryDelta: p.memoryDelta,
+          ownMemoryDelta: own.ownMemoryDelta
+        };
+      }),
+      slowHooks: this.#computeSlowHooks(new Set(allPhases.map((p) => p.name))),
+      modules: [...this.#modules].sort((a, b) => b.setupTime - a.setupTime),
+      bundlerPlugins: [...this.#bundlerPluginTimings.entries()].map(([name, hookMap]) => {
+        const hooks = {};
+        for (const [hookName, t] of hookMap) {
+          hooks[hookName] = {
+            totalTime: round(t.totalTime),
+            count: t.count,
+            maxTime: round(t.maxTime),
+            avgTime: round(t.totalTime / t.count)
+          };
+        }
+        return { name, hooks };
+      }).sort((a, b) => {
+        const aTotal = Object.values(a.hooks).reduce((s, h) => s + h.totalTime, 0);
+        const bTotal = Object.values(b.hooks).reduce((s, h) => s + h.totalTime, 0);
+        return bTotal - aTotal;
+      }),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  printReport(options) {
+    const report = this.getReport();
+    const isSubPhase = (name) => name.startsWith("module:") || name.startsWith("vite:");
+    const topPhases = report.phases.filter((p) => !isSubPhase(p.name));
+    const subPhases = report.phases.filter((p) => isSubPhase(p.name));
+    consola.log("");
+    consola.log(colors.bold(colors.cyan(` ${options?.title || "Nuxt Performance Report"}`)));
+    consola.log("");
+    const colPhase = 24;
+    const colDuration = 10;
+    const colRss = 14;
+    const colHeap = 14;
+    const maxDuration = Math.max(...topPhases.map((p) => p.ownDuration), 1);
+    const header = [
+      pad(colors.bold("Phase"), colPhase),
+      pad(colors.bold("Duration"), colDuration, "right"),
+      pad(colors.bold("RSS Delta"), colRss, "right"),
+      pad(colors.bold("Heap Delta"), colHeap, "right")
+    ].join("  ");
+    consola.log(`  ${header}`);
+    const separator = "  " + colors.dim("\u2500".repeat(colPhase + colDuration + colRss + colHeap + 6));
+    consola.log(separator);
+    const maxRss = Math.max(...topPhases.map((p) => Math.abs(p.ownMemoryDelta.rss)), 1);
+    const barMax = 20;
+    for (const phase of topPhases) {
+      const dur = phase.ownDuration;
+      const rss = phase.ownMemoryDelta.rss;
+      const heap = phase.ownMemoryDelta.heapUsed;
+      const durBar = dur > 0 ? Math.max(1, Math.round(Math.log(dur + 1) / Math.log(maxDuration + 1) * (barMax / 2))) : 0;
+      const memBar = Math.abs(rss) > 0 ? Math.max(0, Math.round(Math.abs(rss) / maxRss * (barMax / 2))) : 0;
+      const durColor = dur > 1e3 ? colors.red : dur > 200 ? colors.yellow : colors.green;
+      const memColor = Math.abs(rss) > 50 * 1024 * 1024 ? colors.red : Math.abs(rss) > 10 * 1024 * 1024 ? colors.yellow : colors.green;
+      const bar = durColor("\u2588".repeat(durBar)) + memColor("\u2591".repeat(memBar));
+      const row = [
+        pad(phase.name, colPhase),
+        pad(durColor(formatDuration(dur)), colDuration, "right"),
+        pad(memColor((rss >= 0 ? "+" : "") + formatBytes(rss)), colRss, "right"),
+        pad((heap >= 0 ? "+" : "") + formatBytes(heap), colHeap, "right")
+      ].join("  ");
+      consola.log(`  ${row}  ${bar}`);
+    }
+    consola.log(separator);
+    const totalRow = [
+      pad(colors.bold("Total"), colPhase),
+      pad(colors.bold(formatDuration(report.totalDuration)), colDuration, "right"),
+      pad(colors.bold((report.totalMemoryDelta.rss >= 0 ? "+" : "") + formatBytes(report.totalMemoryDelta.rss)), colRss, "right"),
+      pad(colors.bold((report.totalMemoryDelta.heapUsed >= 0 ? "+" : "") + formatBytes(report.totalMemoryDelta.heapUsed)), colHeap, "right")
+    ].join("  ");
+    consola.log(`  ${totalRow}`);
+    consola.log("");
+    const significantModules = report.modules.filter((m) => m.setupTime > 5);
+    if (significantModules.length > 0) {
+      consola.log(colors.bold(` Modules`));
+      consola.log("");
+      for (const mod of significantModules) {
+        const durColor = mod.setupTime > 500 ? colors.red : mod.setupTime > 100 ? colors.yellow : colors.dim;
+        consola.log(`  ${colors.dim("\u2022")} ${mod.name} ${colors.dim("\u2014")} ${durColor(formatDuration(mod.setupTime))}`);
+      }
+      consola.log("");
+    }
+    if (report.bundlerPlugins.length > 0) {
+      const rows = [];
+      for (const plugin of report.bundlerPlugins) {
+        for (const [hook, timing] of Object.entries(plugin.hooks)) {
+          if (timing.avgTime > 0.5) {
+            rows.push({ plugin: plugin.name, hook, timing });
+          }
+        }
+      }
+      rows.sort((a, b) => b.timing.avgTime - a.timing.avgTime);
+      if (rows.length > 0) {
+        consola.log(colors.bold(` Bundler Plugins`));
+        consola.log("");
+        for (const { plugin, hook, timing } of rows.slice(0, 15)) {
+          const durColor = timing.avgTime > 10 ? colors.red : timing.avgTime > 2 ? colors.yellow : colors.dim;
+          const avgLabel = formatDuration(timing.avgTime) + "/file";
+          const maxLabel = timing.maxTime > timing.avgTime * 2 ? `, max ${formatDuration(timing.maxTime)}` : "";
+          consola.log(`  ${colors.dim("\u2022")} ${plugin} ${colors.dim(hook)} ${colors.dim("\u2014")} ${durColor(avgLabel)}${colors.dim(maxLabel)} ${colors.dim(`(${timing.count} calls)`)}`);
+        }
+        consola.log("");
+      }
+    }
+    if (report.slowHooks.length > 0) {
+      consola.log(colors.bold(colors.yellow(` Slow Hooks (>${SLOW_HOOK_THRESHOLD_MS}ms own time)`)));
+      consola.log("");
+      for (const hook of report.slowHooks) {
+        const durColor = hook.ownDuration > 500 ? colors.red : hook.ownDuration > 200 ? colors.yellow : colors.dim;
+        const ownLabel = hook.ownDuration !== hook.duration ? `${formatDuration(hook.ownDuration)} own / ${formatDuration(hook.duration)} total` : formatDuration(hook.ownDuration);
+        consola.log(`  ${colors.dim("\u2022")} ${hook.name} ${colors.dim("\u2014")} ${durColor(ownLabel)} ${colors.dim(`(${hook.phase})`)}`);
+      }
+      consola.log("");
+    }
+    const significantSubs = subPhases.filter((p) => p.duration > 5);
+    if (significantSubs.length > 0) {
+      consola.log(colors.bold(` Details`));
+      consola.log("");
+      for (const phase of significantSubs) {
+        const durColor = phase.duration > 500 ? colors.red : phase.duration > 100 ? colors.yellow : colors.dim;
+        consola.log(`  ${colors.dim("\u2022")} ${phase.name} ${colors.dim("\u2014")} ${durColor(formatDuration(phase.duration))}`);
+      }
+      consola.log("");
+    }
+  }
+  /**
+   * Generate trace events in Chrome Trace Event format.
+   * The output can be loaded in chrome://tracing or https://ui.perfetto.dev
+   */
+  getTraceEvents() {
+    const events = [];
+    const pid = 1;
+    const tidPhases = 1;
+    const tidHooks = 2;
+    const tidPluginBase = 10;
+    const toUs = (ms) => Math.round(ms * 1e3 + this.#baseTs);
+    events.push(
+      { name: "process_name", ph: "M", ts: 0, pid, tid: 0, cat: "", args: { name: "Nuxt Build" } },
+      { name: "thread_name", ph: "M", ts: 0, pid, tid: tidPhases, cat: "", args: { name: "Build" } },
+      { name: "thread_name", ph: "M", ts: 0, pid, tid: tidHooks, cat: "", args: { name: "Hooks" } }
+    );
+    const durUs = (ms) => Math.round(ms * 1e3);
+    const globalEnd = performance.now();
+    events.push(
+      { name: "nuxt build", cat: "build", ph: "B", ts: toUs(this.#globalStart), pid, tid: tidPhases },
+      { name: "nuxt build", cat: "build", ph: "E", ts: toUs(globalEnd), pid, tid: tidPhases }
+    );
+    for (const phase of this.#phases) {
+      events.push(
+        {
+          name: phase.name,
+          cat: "phase",
+          ph: "B",
+          ts: toUs(phase.startTime),
+          pid,
+          tid: tidPhases,
+          args: {
+            memoryBefore: { rss: phase.memoryBefore.rss, heapUsed: phase.memoryBefore.heapUsed }
+          }
+        },
+        {
+          name: phase.name,
+          cat: "phase",
+          ph: "E",
+          ts: toUs(phase.endTime),
+          pid,
+          tid: tidPhases,
+          args: {
+            memoryDelta: { rss: phase.memoryDelta.rss, heapUsed: phase.memoryDelta.heapUsed }
+          }
+        }
+      );
+    }
+    for (const hp of this.#hookPhases) {
+      const name = hp.name.startsWith("hook:") ? hp.name.slice(5) : hp.name;
+      events.push(
+        { name, cat: "hook", ph: "B", ts: toUs(hp.startTime), pid, tid: tidHooks },
+        { name, cat: "hook", ph: "E", ts: toUs(hp.endTime), pid, tid: tidHooks }
+      );
+    }
+    const viteSpans = this.#bundlerPluginSpans.filter((s) => !s.pluginName.startsWith("nitro:"));
+    const nitroSpans = this.#bundlerPluginSpans.filter((s) => s.pluginName.startsWith("nitro:"));
+    const emitPluginSpans = (spans, label, baseTid) => {
+      if (spans.length === 0) {
+        return;
+      }
+      const sorted = [...spans].sort((a, b) => a.startTime - b.startTime);
+      const laneEnds = [];
+      for (const span of sorted) {
+        const endTime = span.startTime + span.durationMs;
+        let lane = laneEnds.findIndex((end) => end < span.startTime);
+        if (lane === -1) {
+          lane = laneEnds.length;
+          laneEnds.push(0);
+        }
+        laneEnds[lane] = endTime;
+        const tid = baseTid + lane;
+        events.push({
+          name: `${span.pluginName}:${span.hookName}`,
+          cat: label,
+          ph: "X",
+          ts: toUs(span.startTime),
+          dur: durUs(span.durationMs),
+          pid,
+          tid
+        });
+      }
+      for (let i = 0; i < laneEnds.length; i++) {
+        const suffix = laneEnds.length > 1 ? ` ${i + 1}` : "";
+        events.push({
+          name: "thread_name",
+          ph: "M",
+          ts: 0,
+          pid,
+          tid: baseTid + i,
+          cat: "",
+          args: { name: `${label}${suffix}` }
+        });
+      }
+    };
+    emitPluginSpans(viteSpans, "Vite Plugins", tidPluginBase);
+    emitPluginSpans(nitroSpans, "Nitro Plugins", tidPluginBase + 100);
+    for (const phase of this.#phases) {
+      events.push(
+        {
+          name: "Memory",
+          cat: "memory",
+          ph: "C",
+          ts: toUs(phase.startTime),
+          pid,
+          tid: 0,
+          args: { rss: phase.memoryBefore.rss, heapUsed: phase.memoryBefore.heapUsed }
+        },
+        {
+          name: "Memory",
+          cat: "memory",
+          ph: "C",
+          ts: toUs(phase.endTime),
+          pid,
+          tid: 0,
+          args: { rss: phase.memoryAfter.rss, heapUsed: phase.memoryAfter.heapUsed }
+        }
+      );
+    }
+    return events;
+  }
+  writeReport(buildDir, options) {
+    const report = this.getReport();
+    const reportPath = join(buildDir, "perf-report.json");
+    const relativeReportPath = relative(process.cwd(), reportPath).replace(/^(?![^.]{1,2}\/)/, "./");
+    const tracePath = join(buildDir, "perf-trace.json");
+    const relativeTracePath = relative(process.cwd(), tracePath).replace(/^(?![^.]{1,2}\/)/, "./");
+    try {
+      mkdirSync(buildDir, { recursive: true });
+      writeFileSync(reportPath, JSON.stringify(report, null, 2), "utf-8");
+      writeFileSync(tracePath, JSON.stringify({ traceEvents: this.getTraceEvents() }), "utf-8");
+      if (!options?.quiet) {
+        consola.log(colors.dim(` Data dump written to ${relativeReportPath}`));
+        consola.log(colors.dim(` Trace written to ${relativeTracePath} (load in \`https://ui.perfetto.dev\`)`));
+        consola.log("");
+      }
+    } catch {
+    }
+    return reportPath;
+  }
+  dispose() {
+    this.#unsubscribe?.();
+  }
+  #computeSlowHooks(reportedPhaseNames) {
+    const hooks = [];
+    for (const hp of this.#hookPhases) {
+      if (hp.duration < SLOW_HOOK_THRESHOLD_MS) {
+        continue;
+      }
+      const hookName = hp.name.slice(5);
+      if (reportedPhaseNames.has(hookName)) {
+        continue;
+      }
+      let attributedTime = 0;
+      for (const phase of this.#phases) {
+        const overlapStart = Math.max(phase.startTime, hp.startTime);
+        const overlapEnd = Math.min(phase.endTime, hp.endTime);
+        if (overlapEnd > overlapStart) {
+          attributedTime += overlapEnd - overlapStart;
+        }
+      }
+      for (const other of this.#hookPhases) {
+        if (other === hp) {
+          continue;
+        }
+        if (other.startTime >= hp.startTime && other.endTime <= hp.endTime) {
+          attributedTime += other.duration;
+        }
+      }
+      const ownDuration = round(hp.duration - round(attributedTime));
+      if (ownDuration >= SLOW_HOOK_THRESHOLD_MS) {
+        const parentPhase = this.#phases.find(
+          (p) => p.startTime <= hp.startTime && p.endTime >= hp.endTime
+        );
+        hooks.push({
+          name: hookName,
+          duration: hp.duration,
+          ownDuration,
+          phase: parentPhase?.name || "(between phases)"
+        });
+      }
+    }
+    return hooks.sort((a, b) => b.ownDuration - a.ownDuration);
+  }
+}
+
 const schemaModule = defineNuxtModule({
   meta: {
     name: "nuxt:nuxt-config-schema"
@@ -4359,654 +6190,201 @@ declare module '@nuxt/schema' {
   interface NuxtOptions extends Omit<NuxtCustomSchema, 'appConfig'> {}
   interface CustomAppConfig extends _CustomAppConfig {}
 }
-
-declare module 'nuxt/schema' {
-  interface NuxtConfig extends Omit<NuxtCustomSchema, 'appConfig'> {}
-  interface NuxtOptions extends Omit<NuxtCustomSchema, 'appConfig'> {}
-  interface CustomAppConfig extends _CustomAppConfig {}
-}
-`;
-      const typesPath = resolve(nuxt.options.buildDir, "schema/nuxt.schema.d.ts");
-      await writeFile(typesPath, types, "utf8");
-      await nuxt.hooks.callHook("schema:written");
-    }
-  }
-});
-
-const internalOrderMap = {
-  // -40: custom payload revivers (user)
-  "user-revivers": -40,
-  // -20: pre (user) <-- pre mapped to this
-  "user-pre": -20,
-  // 0: default (user) <-- default behavior
-  "user-default": 0,
-  // +20: post (user) <-- post mapped to this
-  "user-post": 20};
-const orderMap = {
-  pre: internalOrderMap["user-pre"],
-  default: internalOrderMap["user-default"],
-  post: internalOrderMap["user-post"]
-};
-const metaCache = {};
-function extractMetadata(code, loader = "ts") {
-  let meta = {};
-  if (metaCache[code]) {
-    return metaCache[code];
-  }
-  if (/defineNuxtPlugin\s*\([\w(]/.test(code)) {
-    return {};
-  }
-  parseAndWalk(code, `file.${loader}`, (node) => {
-    if (node.type !== "CallExpression" || node.callee.type !== "Identifier") {
-      return;
-    }
-    const name = "name" in node.callee && node.callee.name;
-    if (name !== "defineNuxtPlugin" && name !== "definePayloadPlugin") {
-      return;
-    }
-    if (name === "definePayloadPlugin") {
-      meta.order = internalOrderMap["user-revivers"];
-    }
-    const metaArg = node.arguments[1];
-    if (metaArg) {
-      if (metaArg.type !== "ObjectExpression") {
-        throw new Error("Invalid plugin metadata");
-      }
-      meta = extractMetaFromObject(metaArg.properties);
-    }
-    const plugin = node.arguments[0];
-    if (plugin?.type === "ObjectExpression") {
-      meta = defu(extractMetaFromObject(plugin.properties), meta);
-    }
-    meta.order ||= orderMap[meta.enforce || "default"] || orderMap.default;
-    delete meta.enforce;
-  });
-  metaCache[code] = meta;
-  return meta;
-}
-const keys = {
-  name: "name",
-  order: "order",
-  enforce: "enforce",
-  dependsOn: "dependsOn"
-};
-function isMetadataKey(key) {
-  return typeof key !== "string" ? key.name in keys : key in keys;
-}
-function extractMetaFromObject(properties) {
-  const meta = {};
-  for (const property of properties) {
-    if (property.type === "SpreadElement" || !("name" in property.key)) {
-      throw new Error("Invalid plugin metadata");
-    }
-    const propertyKey = property.key.name;
-    if (!isMetadataKey(propertyKey)) {
-      continue;
-    }
-    if (property.value.type === "Literal") {
-      meta[propertyKey] = property.value.value;
-    }
-    if (property.value.type === "UnaryExpression" && property.value.argument.type === "Literal") {
-      meta[propertyKey] = JSON.parse(property.value.operator + property.value.argument.raw);
-    }
-    if (propertyKey === "dependsOn" && property.value.type === "ArrayExpression") {
-      if (property.value.elements.some((e) => !e || e.type !== "Literal" || typeof e.value !== "string")) {
-        throw new Error("dependsOn must take an array of string literals");
-      }
-      meta[propertyKey] = property.value.elements.map((e) => e.value);
-    }
-  }
-  return meta;
-}
-const RemovePluginMetadataPlugin = (nuxt) => createUnplugin(() => {
-  return {
-    name: "nuxt:remove-plugin-metadata",
-    transform(code, id) {
-      id = normalize(id);
-      const plugin = nuxt.apps.default?.plugins.find((p) => p.src === id);
-      if (!plugin) {
-        return;
-      }
-      if (!code.trim()) {
-        logger.warn(`Plugin \`${plugin.src}\` has no content.`);
-        return {
-          code: "export default () => {}",
-          map: null
-        };
-      }
-      const exports$1 = findExports(code);
-      const defaultExport = exports$1.find((e) => e.type === "default" || e.name === "default");
-      if (!defaultExport) {
-        logger.warn(`Plugin \`${plugin.src}\` has no default export and will be ignored at build time. Add \`export default defineNuxtPlugin(() => {})\` to your plugin.`);
-        return {
-          code: "export default () => {}",
-          map: null
-        };
-      }
-      const s = new MagicString(code);
-      let wrapped = false;
-      const wrapperNames = /* @__PURE__ */ new Set(["defineNuxtPlugin", "definePayloadPlugin"]);
-      try {
-        parseAndWalk(code, id, (node) => {
-          if (node.type === "ImportSpecifier" && node.imported.type === "Identifier" && (node.imported.name === "defineNuxtPlugin" || node.imported.name === "definePayloadPlugin")) {
-            wrapperNames.add(node.local.name);
-          }
-          if (node.type !== "CallExpression" || node.callee.type !== "Identifier") {
-            return;
-          }
-          const name = "name" in node.callee && node.callee.name;
-          if (!name || !wrapperNames.has(name)) {
-            return;
-          }
-          wrapped = true;
-          if (!("order" in plugin) && !("name" in plugin)) {
-            return;
-          }
-          for (const [argIndex, arg] of node.arguments.entries()) {
-            if (arg.type !== "ObjectExpression") {
-              continue;
-            }
-            for (const [propertyIndex, property] of arg.properties.entries()) {
-              if (property.type === "SpreadElement" || !("name" in property.key)) {
-                continue;
-              }
-              const propertyKey = property.key.name;
-              if (propertyKey === "order" || propertyKey === "enforce" || propertyKey === "name") {
-                const nextNode = arg.properties[propertyIndex + 1] || node.arguments[argIndex + 1];
-                const nextIndex = nextNode?.start || arg.end - 1;
-                s.remove(property.start, nextIndex);
-              }
-            }
-          }
-        });
-      } catch (e) {
-        logger.error(e);
-        return;
-      }
-      if (!wrapped) {
-        logger.warn(`Plugin \`${plugin.src}\` is not wrapped in \`defineNuxtPlugin\`. It is advised to wrap your plugins as in the future this may enable enhancements.`);
-      }
-      if (s.hasChanged()) {
-        return {
-          code: s.toString(),
-          map: nuxt.options.sourcemap.client || nuxt.options.sourcemap.server ? s.generateMap({ hires: true }) : null
-        };
-      }
-    }
-  };
-});
-
-const AsyncContextInjectionPlugin = (nuxt) => createUnplugin(() => {
-  return {
-    name: "nuxt:vue-async-context",
-    transformInclude(id) {
-      return isVue(id, { type: ["template", "script"] });
-    },
-    transform: {
-      filter: {
-        code: { include: /_withAsyncContext/ }
-      },
-      handler(code) {
-        const s = new MagicString(code);
-        s.prepend('import { withAsyncContext as _withAsyncContext } from "#app/composables/asyncContext";\n');
-        s.replace(/withAsyncContext as _withAsyncContext,?/, "");
-        if (s.hasChanged()) {
-          return {
-            code: s.toString(),
-            map: nuxt.options.sourcemap.client || nuxt.options.sourcemap.server ? s.generateMap({ hires: true }) : void 0
-          };
-        }
-      }
-    }
-  };
-});
-
-function processImports(imports) {
-  const directImports = /* @__PURE__ */ new Map();
-  const namespaces = /* @__PURE__ */ new Map();
-  for (const i of imports) {
-    const resolvedSpecifier = stripExtension(resolveAlias$1(i.specifier));
-    const namedImports = i.namedImports ?? {};
-    for (const originalIdentifier in namedImports) {
-      const localIdentifier = namedImports[originalIdentifier] || originalIdentifier;
-      directImports.set(localIdentifier, {
-        originalName: originalIdentifier,
-        source: resolvedSpecifier
-      });
-    }
-    if (i.namespacedImport || i.defaultImport) {
-      if (!namespaces.has(resolvedSpecifier)) {
-        namespaces.set(resolvedSpecifier, {
-          namespaces: /* @__PURE__ */ new Set()
-        });
-      }
-    }
-    if (i.defaultImport) {
-      const namespace = i.defaultImport;
-      const entry = namespaces.get(resolvedSpecifier);
-      entry.namespaces.add(namespace);
-      directImports.set(i.defaultImport, {
-        originalName: "default",
-        source: resolvedSpecifier
-      });
-    } else if (i.namespacedImport) {
-      const namespace = i.namespacedImport;
-      const entry = namespaces.get(resolvedSpecifier);
-      entry.namespaces.add(namespace);
-    }
-  }
-  return {
-    directImports,
-    namespaces
-  };
-}
-function parseStaticFunctionCall(node, filter) {
-  const callExpression = node.type === "CallExpression" ? node : node.type === "ChainExpression" && node.expression.type === "CallExpression" ? node.expression : null;
-  if (!callExpression) {
-    return null;
-  }
-  let functionName;
-  let identifierNode;
-  if (callExpression.callee.type === "Identifier") {
-    functionName = callExpression.callee.name;
-    identifierNode = callExpression.callee;
-  } else if (callExpression.callee.type === "ParenthesizedExpression") {
-    if (callExpression.callee.expression.type === "Identifier") {
-      functionName = callExpression.callee.expression.name;
-      identifierNode = callExpression.callee;
-    } else if ((callExpression.callee.expression.type === "TSAsExpression" || callExpression.callee.expression.type === "TSTypeAssertion" || callExpression.callee.expression.type === "TSNonNullExpression") && callExpression.callee.expression.expression.type === "Identifier") {
-      functionName = callExpression.callee.expression.expression.name;
-      identifierNode = callExpression.callee;
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig extends Omit<NuxtCustomSchema, 'appConfig'> {}
+  interface NuxtOptions extends Omit<NuxtCustomSchema, 'appConfig'> {}
+  interface CustomAppConfig extends _CustomAppConfig {}
+}
+`;
+      const typesPath = resolve(nuxt.options.buildDir, "schema/nuxt.schema.d.ts");
+      await writeFile(typesPath, types, "utf8");
+      await nuxt.hooks.callHook("schema:written");
     }
   }
-  if (functionName && identifierNode && filter.test(functionName)) {
-    return {
-      name: functionName,
-      namespace: null,
-      node: identifierNode,
-      callExpression
-    };
+});
+
+const internalOrderMap = {
+  // -40: custom payload revivers (user)
+  "user-revivers": -40,
+  // -20: pre (user) <-- pre mapped to this
+  "user-pre": -20,
+  // 0: default (user) <-- default behavior
+  "user-default": 0,
+  // +20: post (user) <-- post mapped to this
+  "user-post": 20};
+const orderMap = {
+  pre: internalOrderMap["user-pre"],
+  default: internalOrderMap["user-default"],
+  post: internalOrderMap["user-post"]
+};
+const metaCache = {};
+function extractMetadata(code, loader = "ts") {
+  let meta = {};
+  if (metaCache[code]) {
+    return metaCache[code];
   }
-  function getParsedMemberExpression(memberExpression) {
-    let memberObjectName;
-    if (memberExpression.object.type === "Identifier") {
-      memberObjectName = memberExpression.object.name;
-    } else if (memberExpression.object.type === "ParenthesizedExpression") {
-      if (memberExpression.object.expression.type === "Identifier") {
-        memberObjectName = memberExpression.object.expression.name;
-      } else if ((memberExpression.object.expression.type === "TSAsExpression" || memberExpression.object.expression.type === "TSTypeAssertion" || memberExpression.object.expression.type === "TSNonNullExpression") && memberExpression.object.expression.expression.type === "Identifier") {
-        memberObjectName = memberExpression.object.expression.expression.name;
-      }
-    }
-    if (memberObjectName) {
-      if (memberExpression.property.type === "Identifier" && filter.test(memberExpression.property.name)) {
-        return {
-          name: memberExpression.property.name,
-          namespace: memberObjectName,
-          node: memberExpression.property
-        };
-      }
-      if (memberExpression.property.type === "Literal" && typeof memberExpression.property.value === "string" && filter.test(memberExpression.property.value)) {
-        return {
-          name: memberExpression.property.value,
-          namespace: memberObjectName,
-          node: memberExpression
-        };
-      }
-    }
-    return null;
+  if (/defineNuxtPlugin\s*\([\w(]/.test(code)) {
+    return {};
   }
-  if (callExpression.callee.type === "MemberExpression") {
-    const val = getParsedMemberExpression(callExpression.callee);
-    if (val) {
-      return {
-        ...val,
-        callExpression
-      };
+  parseAndWalk(code, `file.${loader}`, (node) => {
+    if (node.type !== "CallExpression" || node.callee.type !== "Identifier") {
+      return;
     }
-  } else if (callExpression.callee.type === "ParenthesizedExpression" && callExpression.callee.expression.type === "MemberExpression") {
-    const val = getParsedMemberExpression(callExpression.callee.expression);
-    if (val) {
-      return {
-        ...val,
-        node: callExpression.callee,
-        callExpression
-      };
+    const name = "name" in node.callee && node.callee.name;
+    if (name !== "defineNuxtPlugin" && name !== "definePayloadPlugin") {
+      return;
     }
-  }
-  return null;
-}
-function parseStaticExportIdentifiers(node, filter) {
-  if (node.type === "ExportNamedDeclaration" && node.exportKind !== "type") {
-    if (node.declaration?.type === "VariableDeclaration") {
-      return node.declaration.declarations.map((d) => {
-        if (d.id.type === "Identifier" && (true)) {
-          return {
-            localName: d.id.name,
-            exportedName: d.id.name
-          };
-        }
-        return null;
-      }).filter((v) => !!v);
+    if (name === "definePayloadPlugin") {
+      meta.order = internalOrderMap["user-revivers"];
     }
-    if (node.declaration?.type === "FunctionDeclaration") {
-      if (node.declaration.id?.type === "Identifier" && (true)) {
-        return [{
-          localName: node.declaration.id.name,
-          exportedName: node.declaration.id.name
-        }];
+    const metaArg = node.arguments[1];
+    if (metaArg) {
+      if (metaArg.type !== "ObjectExpression") {
+        throw new Error("Invalid plugin metadata");
       }
-      return [];
+      meta = extractMetaFromObject(metaArg.properties);
     }
-    if (node.declaration?.type === "ClassDeclaration") {
-      if (node.declaration.id?.type === "Identifier" && (true)) {
-        return [{
-          localName: node.declaration.id.name,
-          exportedName: node.declaration.id.name
-        }];
-      }
-      return [];
+    const plugin = node.arguments[0];
+    if (plugin?.type === "ObjectExpression") {
+      meta = defu(extractMetaFromObject(plugin.properties), meta);
     }
-    if (node.specifiers && node.specifiers.length) {
-      return node.specifiers.map((s) => {
-        if (s.exported.type === "Identifier" && s.exportKind !== "type" && s.local.type === "Identifier" && (true)) {
-          return {
-            localName: s.local.name,
-            exportedName: s.exported.name
-          };
-        }
-        return null;
-      }).filter((v) => !!v);
+    meta.order ||= orderMap[meta.enforce || "default"] || orderMap.default;
+    delete meta.enforce;
+  });
+  metaCache[code] = meta;
+  return meta;
+}
+const keys = {
+  name: "name",
+  order: "order",
+  enforce: "enforce",
+  dependsOn: "dependsOn"
+};
+function isMetadataKey(key) {
+  return typeof key !== "string" ? key.name in keys : key in keys;
+}
+function extractMetaFromObject(properties) {
+  const meta = {};
+  for (const property of properties) {
+    if (property.type === "SpreadElement" || !("name" in property.key)) {
+      throw new Error("Invalid plugin metadata");
     }
-    return [];
-  }
-  if (node.type === "ExportDefaultDeclaration" && (!node.exportKind || node.exportKind === "value")) {
-    if (node.declaration.type === "Identifier") {
-      return [{
-        localName: node.declaration.name,
-        exportedName: "default"
-      }];
+    const propertyKey = property.key.name;
+    if (!isMetadataKey(propertyKey)) {
+      continue;
     }
-    if (node.declaration.type === "FunctionDeclaration") {
-      if (node.declaration.id?.type === "Identifier") {
-        return [{
-          localName: node.declaration.id.name,
-          exportedName: "default"
-        }];
-      }
-      return [];
+    if (property.value.type === "Literal") {
+      meta[propertyKey] = property.value.value;
     }
-    if (node.declaration.type === "ClassDeclaration") {
-      if (node.declaration.id?.type === "Identifier") {
-        return [{
-          localName: node.declaration.id.name,
-          exportedName: "default"
-        }];
-      }
-      return [];
+    if (property.value.type === "UnaryExpression" && property.value.argument.type === "Literal") {
+      meta[propertyKey] = JSON.parse(property.value.operator + property.value.argument.raw);
     }
-  }
-  if (node.type === "TSExportAssignment") {
-    if (node.expression.type === "Identifier") {
-      {
-        return [{
-          localName: node.expression.name,
-          exportedName: "default"
-        }];
+    if (propertyKey === "dependsOn" && property.value.type === "ArrayExpression") {
+      if (property.value.elements.some((e) => !e || e.type !== "Literal" || typeof e.value !== "string")) {
+        throw new Error("dependsOn must take an array of string literals");
       }
+      meta[propertyKey] = property.value.elements.map((e) => e.value);
     }
   }
-  return [];
-}
-
-const stringTypes = ["Literal", "TemplateLiteral"];
-const NUXT_LIB_RE = /node_modules\/(?:nuxt|nuxt3|nuxt-nightly|@nuxt)\//;
-const SUPPORTED_EXT_RE$1 = /\.(?:m?[jt]sx?|vue)/;
-const SCRIPT_RE$1 = /(?<=<script[^>]*>)[\s\S]*?(?=<\/script>)/i;
-const NUXT_INJECTED_MARKER = "/* nuxt-injected */";
-function shouldTransformFile(id, extensions) {
-  const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
-  return !NUXT_LIB_RE.test(pathname) && (extensions instanceof RegExp ? extensions.test(pathname) : new RegExp(`\\.(${extensions.map((e) => escapeRE(e)).join("|")})$`).test(pathname)) && parseQuery(search).type !== "style" && !parseQuery(search).macro;
+  return meta;
 }
-const KeyedFunctionsPlugin = (options) => createUnplugin(() => {
-  const namesToSourcesToFunctionMeta = /* @__PURE__ */ new Map();
-  const defaultExportSources = /* @__PURE__ */ new Set();
-  for (const f of options.keyedFunctions) {
-    let functionName = f.name;
-    const fnSource = typeof f.source === "string" ? stripExtension(f.source) : "";
-    if (f.name === "default") {
-      const parsedSource = parse$1(f.source);
-      defaultExportSources.add(parsedSource.name);
-      functionName = camelCase(parsedSource.name);
-    }
-    if (import.meta.dev) {
-      const sourcesToFunctionMeta2 = namesToSourcesToFunctionMeta.get(functionName);
-      const existingEntry = sourcesToFunctionMeta2?.get(fnSource);
-      if (existingEntry?.source && existingEntry.source === fnSource) {
-        logger.warn(`[nuxt:compiler] [keyed-functions] Duplicate function name \`${functionName}\`${functionName !== f.name ? ` defined as \`${f.name}\`` : ""} with ${f.source ? `the same source \`${f.source}\`` : "no source"} found. Overwriting the existing entry.`);
+const RemovePluginMetadataPlugin = (nuxt) => createUnplugin(() => {
+  return {
+    name: "nuxt:remove-plugin-metadata",
+    transform(code, id) {
+      id = normalize(id);
+      const plugin = nuxt.apps.default?.plugins.find((p) => p.src === id);
+      if (!plugin) {
+        return;
       }
-    }
-    let sourcesToFunctionMeta = namesToSourcesToFunctionMeta.get(functionName);
-    if (!sourcesToFunctionMeta) {
-      sourcesToFunctionMeta = /* @__PURE__ */ new Map();
-      namesToSourcesToFunctionMeta.set(functionName, sourcesToFunctionMeta);
-    }
-    sourcesToFunctionMeta.set(fnSource, {
-      ...f,
-      // TODO: use only `fnSource` in Nuxt 5
-      source: typeof f.source === "string" ? fnSource : f.source
-    });
-  }
-  const sources = /* @__PURE__ */ new Set();
-  for (const sourcesToFunctionMeta of namesToSourcesToFunctionMeta.values()) {
-    for (const f of sourcesToFunctionMeta.values()) {
-      if (f.source && typeof f.source === "string") {
-        sources.add(f.source);
+      if (!code.trim()) {
+        logger.warn(`Plugin \`${plugin.src}\` has no content.`);
+        return {
+          code: "export default () => {}",
+          map: null
+        };
+      }
+      const exports$1 = findExports(code);
+      const defaultExport = exports$1.find((e) => e.type === "default" || e.name === "default");
+      if (!defaultExport) {
+        logger.warn(`Plugin \`${plugin.src}\` has no default export and will be ignored at build time. Add \`export default defineNuxtPlugin(() => {})\` to your plugin.`);
+        return {
+          code: "export default () => {}",
+          map: null
+        };
       }
-    }
-  }
-  const CODE_INCLUDE_RE = new RegExp(`\\b(${[...namesToSourcesToFunctionMeta.keys(), ...defaultExportSources].map((f) => escapeRE(f)).join("|")})\\b`);
-  return {
-    name: "nuxt:compiler:keyed-functions",
-    enforce: "post",
-    transformInclude: (id) => shouldTransformFile(id, SUPPORTED_EXT_RE$1),
-    transform: {
-      filter: {
-        code: { include: CODE_INCLUDE_RE }
-      },
-      async handler(code, _id) {
-        const { 0: script = code, index: codeIndex = 0 } = code.match(SCRIPT_RE$1) || { 0: code, index: 0 };
-        const id = stripExtension(_id);
-        const { directImports, namespaces } = processImports(findStaticImports(script).map((i) => parseStaticImport(i)));
-        const shouldConsiderExports = sources.has(id);
-        const localNamesToExportedName = /* @__PURE__ */ new Map();
-        const possibleLocalFunctionNames = new Set(namesToSourcesToFunctionMeta.keys());
-        for (const [localName, directImport] of directImports) {
-          const functionName = directImport.originalName === "default" ? camelCase(parse$1(directImport.source).name) : directImport.originalName;
-          if (namesToSourcesToFunctionMeta.has(functionName)) {
-            possibleLocalFunctionNames.add(localName);
-          }
-        }
-        const autoImports = await options.getAutoImports();
-        const autoImportsToSources = new Map(autoImports.map((i) => [i.as || i.name, i.from]));
-        function getFunctionMetaByLocalName(localName, source) {
-          if (!localName) {
-            return;
-          }
-          const exportedName = localNamesToExportedName.get(localName);
-          if (exportedName) {
-            return namesToSourcesToFunctionMeta.get(exportedName)?.get(source);
-          }
-          const directImport = directImports.get(localName);
-          if (directImport) {
-            const functionName = directImport.originalName === "default" ? camelCase(parse$1(directImport.source).name) : directImport.originalName;
-            const sourcesToMetas = namesToSourcesToFunctionMeta.get(functionName);
-            if (!sourcesToMetas) {
-              return;
-            }
-            const fnMeta = sourcesToMetas.get(source);
-            if (fnMeta) {
-              return fnMeta;
-            }
-            const backwardsCompatibleFnMeta = sourcesToMetas.get("");
-            if (backwardsCompatibleFnMeta?.source === void 0) {
-              const autoImportResolvedSource = stripExtension(resolveAlias$1(autoImportsToSources.get(localName) ?? ""));
-              if (autoImportResolvedSource === source) {
-                return backwardsCompatibleFnMeta;
-              }
-            } else if (backwardsCompatibleFnMeta.source instanceof RegExp && backwardsCompatibleFnMeta.source.test(source)) {
-              return backwardsCompatibleFnMeta;
-            }
-            return;
-          }
-          return namesToSourcesToFunctionMeta.get(localName)?.get(source);
-        }
-        function _resolvePath(path) {
-          let p = path;
-          if (isAbsolute(p)) {
-            return p;
-          }
-          p = resolveAlias$1(p, options.alias);
-          if (isAbsolute(p)) {
-            return p;
-          }
-          return join(parse$1(id).dir, p);
-        }
-        const s = new MagicString(code);
-        let count = 0;
-        const scopeTracker = new ScopeTracker({
-          preserveExitedScopes: true
-        });
-        const { program } = parseAndWalk(code, _id, {
-          scopeTracker,
-          enter(node) {
-            if (!shouldConsiderExports) {
-              return;
-            }
-            if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
-              return;
-            }
-            const result = parseStaticExportIdentifiers(node);
-            for (const exportMeta of result) {
-              const { localName, exportedName } = exportMeta;
-              const functionName = exportedName === "default" ? camelCase(parse$1(id).name) : getFunctionMetaByLocalName(exportedName, id)?.name;
-              if (!functionName) {
-                continue;
-              }
-              localNamesToExportedName.set(localName, functionName);
-            }
-          }
-        });
-        scopeTracker.freeze();
-        for (const localName of localNamesToExportedName.keys()) {
-          possibleLocalFunctionNames.add(localName);
-        }
-        const LOCAL_FUNCTION_NAMES_RE = new RegExp(`\\b(${[...possibleLocalFunctionNames].map((f) => escapeRE(f)).join("|")})\\b`);
-        function processKeyedFunction(walkContext, node, handler) {
-          if (node.type !== "CallExpression" && node.type !== "ChainExpression") {
-            return;
-          }
-          const parsedCall = parseStaticFunctionCall(node, LOCAL_FUNCTION_NAMES_RE);
-          if (!parsedCall) {
-            return;
-          }
-          const functionScopeTrackerNode = scopeTracker.getDeclaration(!parsedCall.namespace ? parsedCall.name : parsedCall.namespace);
-          function isKeyedFunctionImport(node2) {
-            return node2?.type === "Import" && node2.importNode.importKind !== "type";
-          }
-          let importSourceResolved;
-          if (localNamesToExportedName.has(parsedCall.name) && functionScopeTrackerNode?.scope === "") {
-            importSourceResolved = id;
-          } else if (isKeyedFunctionImport(functionScopeTrackerNode)) {
-            importSourceResolved = stripExtension(_resolvePath(functionScopeTrackerNode.importNode.source.value));
+      const s = new MagicString(code);
+      let wrapped = false;
+      const wrapperNames = /* @__PURE__ */ new Set(["defineNuxtPlugin", "definePayloadPlugin"]);
+      try {
+        parseAndWalk(code, id, (node) => {
+          if (node.type === "ImportSpecifier" && node.imported.type === "Identifier" && (node.imported.name === "defineNuxtPlugin" || node.imported.name === "definePayloadPlugin")) {
+            wrapperNames.add(node.local.name);
           }
-          if (!importSourceResolved) {
-            walkContext.skip();
+          if (node.type !== "CallExpression" || node.callee.type !== "Identifier") {
             return;
           }
-          const fnMeta = getFunctionMetaByLocalName(parsedCall.name, importSourceResolved);
-          if (!fnMeta) {
-            walkContext.skip();
+          const name = "name" in node.callee && node.callee.name;
+          if (!name || !wrapperNames.has(name)) {
             return;
           }
-          if (!parsedCall.namespace) {
-            if (parsedCall.callExpression.arguments.length >= fnMeta.argumentLength && !parsedCall.callExpression.arguments.some((a) => a.type === "SpreadElement")) {
-              walkContext.skip();
-              return;
-            }
-            if (
-              // the function is imported
-              isKeyedFunctionImport(functionScopeTrackerNode) && // import { useKeyed } from '...'
-              (functionScopeTrackerNode.node.type === "ImportSpecifier" && functionScopeTrackerNode.node.importKind !== "type" || functionScopeTrackerNode.node.type === "ImportDefaultSpecifier" && fnMeta.name === "default") && // the function is imported from the correct source when `source` is specified
-              (typeof fnMeta.source === "string" && stripExtension(fnMeta.source) === importSourceResolved || !fnMeta.source && stripExtension(_resolvePath(autoImportsToSources.get(parsedCall.name) ?? "")) === importSourceResolved || fnMeta.source instanceof RegExp && fnMeta.source.test(importSourceResolved)) || localNamesToExportedName.has(parsedCall.name) && functionScopeTrackerNode?.scope === ""
-            ) {
-              handler({ parsedCall, fnMeta });
-            }
-            walkContext.skip();
+          wrapped = true;
+          if (!("order" in plugin) && !("name" in plugin)) {
             return;
           }
-          if (parsedCall.namespace) {
-            const namespacedImportMeta = namespaces.get(importSourceResolved);
-            const namespaceScopeTrackerNode = scopeTracker.getDeclaration(parsedCall.namespace);
-            if (namespacedImportMeta && namespacedImportMeta.namespaces.has(parsedCall.namespace) && namespaceScopeTrackerNode?.type === "Import" && namespaceScopeTrackerNode.node.type === "ImportNamespaceSpecifier") {
-              handler({ parsedCall, fnMeta });
+          for (const [argIndex, arg] of node.arguments.entries()) {
+            if (arg.type !== "ObjectExpression") {
+              continue;
             }
-            walkContext.skip();
-            return;
-          }
-        }
-        walk(program, {
-          scopeTracker,
-          enter(node) {
-            processKeyedFunction(this, node, ({ parsedCall, fnMeta }) => {
-              const lastArgument = parsedCall.callExpression.arguments[parsedCall.callExpression.arguments.length - 1];
-              if (lastArgument?.type === "Literal" && typeof lastArgument.value === "string" && lastArgument.end + NUXT_INJECTED_MARKER.length + 1 < parsedCall.callExpression.end) {
-                let wasKeyInjected = true;
-                for (let i2 = 0; i2 < NUXT_INJECTED_MARKER.length; i2++) {
-                  if (code[codeIndex + lastArgument.end + 1 + i2] !== NUXT_INJECTED_MARKER[i2]) {
-                    wasKeyInjected = false;
-                    break;
-                  }
-                }
-                if (wasKeyInjected) {
-                  return;
-                }
-              }
-              switch (parsedCall.name) {
-                case "useState":
-                  if (stringTypes.includes(parsedCall.callExpression.arguments[0]?.type) && typeof fnMeta.source === "string" && stripExtension(fnMeta.source) === stripExtension(resolveAlias$1("#app/composables/state", options.alias))) {
-                    return;
-                  }
-                  break;
-                case "useFetch":
-                case "useLazyFetch":
-                  if (stringTypes.includes(parsedCall.callExpression.arguments[1]?.type) && typeof fnMeta.source === "string" && stripExtension(fnMeta.source) === stripExtension(resolveAlias$1("#app/composables/fetch", options.alias))) {
-                    return;
-                  }
-                  break;
-                case "useAsyncData":
-                case "useLazyAsyncData":
-                  if (stringTypes.includes(parsedCall.callExpression.arguments[0]?.type) && typeof fnMeta.source === "string" && stripExtension(fnMeta.source) === stripExtension(resolveAlias$1("#app/composables/asyncData", options.alias))) {
-                    return;
-                  }
-                  break;
+            for (const [propertyIndex, property] of arg.properties.entries()) {
+              if (property.type === "SpreadElement" || !("name" in property.key)) {
+                continue;
               }
-              let i = codeIndex + parsedCall.callExpression.end - 2;
-              while (i >= codeIndex + parsedCall.callExpression.start && isWhitespace(code[i])) {
-                i--;
+              const propertyKey = property.key.name;
+              if (propertyKey === "order" || propertyKey === "enforce" || propertyKey === "name") {
+                const nextNode = arg.properties[propertyIndex + 1] || node.arguments[argIndex + 1];
+                const nextIndex = nextNode?.start || arg.end - 1;
+                s.remove(property.start, nextIndex);
               }
-              const endsWithComma = code[i] === ",";
-              s.appendLeft(
-                codeIndex + parsedCall.callExpression.end - 1,
-                (parsedCall.callExpression.arguments.length && !endsWithComma ? ", " : "") + "'$" + hash(`${_id}-${++count}`).slice(0, 10) + `' ${NUXT_INJECTED_MARKER}`
-              );
-            });
+            }
           }
         });
+      } catch (e) {
+        logger.error(e);
+        return;
+      }
+      if (!wrapped) {
+        logger.warn(`Plugin \`${plugin.src}\` is not wrapped in \`defineNuxtPlugin\`. It is advised to wrap your plugins as in the future this may enable enhancements.`);
+      }
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: nuxt.options.sourcemap.client || nuxt.options.sourcemap.server ? s.generateMap({ hires: true }) : null
+        };
+      }
+    }
+  };
+});
+
+const AsyncContextInjectionPlugin = (nuxt) => createUnplugin(() => {
+  return {
+    name: "nuxt:vue-async-context",
+    transformInclude(id) {
+      return isVue(id, { type: ["template", "script"] });
+    },
+    transform: {
+      filter: {
+        code: { include: /_withAsyncContext/ }
+      },
+      handler(code) {
+        const s = new MagicString(code);
+        s.prepend('import { withAsyncContext as _withAsyncContext } from "#app/composables/asyncContext";\n');
+        s.replace(/withAsyncContext as _withAsyncContext,?/, "");
         if (s.hasChanged()) {
           return {
             code: s.toString(),
-            map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
+            map: nuxt.options.sourcemap.client || nuxt.options.sourcemap.server ? s.generateMap({ hires: true }) : void 0
           };
         }
       }
@@ -5071,8 +6449,10 @@ function PrehydrateTransformPlugin(options = {}) {
 
 const functionsToExtract = /* @__PURE__ */ new Set(["useAsyncData", "useLazyAsyncData"]);
 const FUNCTIONS_RE = /\buse(?:Lazy)?AsyncData\b/;
-const SUPPORTED_EXT_RE = /\.(?:m?[jt]sx?|vue)$/;
+const SUPPORTED_EXT_RE = /^[^?]*\.(?:m?[jt]sx?|vue)(?:$|\?)/;
 const SCRIPT_RE = /(?<=<script[^>]*>)[\s\S]*?(?=<\/script>)/i;
+const STYLE_QUERY_RE = /[?&]type=style/;
+const MACRO_QUERY_RE = /[?&]macro(?:=|&|$)/;
 const ExtractAsyncDataHandlersPlugin = (options) => createUnplugin(() => {
   const asyncDatas = {};
   let count = 0;
@@ -5089,14 +6469,11 @@ const ExtractAsyncDataHandlersPlugin = (options) => createUnplugin(() => {
         return asyncDatas[id];
       }
     },
-    transformInclude(id) {
-      const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
-      return SUPPORTED_EXT_RE.test(pathname) && parseQuery(search).type !== "style" && !parseQuery(search).macro;
-    },
     transform: {
       filter: {
         id: {
-          exclude: [/nuxt\/(src|dist)\/app/]
+          include: SUPPORTED_EXT_RE,
+          exclude: [/nuxt\/(src|dist)\/app/, STYLE_QUERY_RE, MACRO_QUERY_RE]
         },
         code: { include: FUNCTIONS_RE }
       },
@@ -5310,8 +6687,13 @@ function escapeDirectory(path) {
 function createNuxt(options) {
   const hooks = createHooks();
   const { callHook, callHookParallel, callHookWith } = hooks;
-  hooks.callHook = (...args) => runWithNuxtContext(nuxt, () => callHook(...args));
-  hooks.callHookParallel = (...args) => runWithNuxtContext(nuxt, () => callHookParallel(...args));
+  if (options.experimental.asyncCallHook) {
+    hooks.callHook = (...args) => Promise.resolve().then(() => runWithNuxtContext(nuxt, () => callHook(...args)));
+    hooks.callHookParallel = (...args) => Promise.resolve().then(() => runWithNuxtContext(nuxt, () => callHookParallel(...args)) ?? []);
+  } else {
+    hooks.callHook = (...args) => runWithNuxtContext(nuxt, () => callHook(...args));
+    hooks.callHookParallel = (...args) => runWithNuxtContext(nuxt, () => callHookParallel(...args));
+  }
   hooks.callHookWith = (...args) => runWithNuxtContext(nuxt, () => callHookWith(...args));
   const nuxt = {
     __name: randomUUID(),
@@ -5322,7 +6704,9 @@ function createNuxt(options) {
     addHooks: hooks.addHooks,
     hook: hooks.hook,
     ready: () => runWithNuxtContext(nuxt, () => initNuxt(nuxt)),
-    close: () => hooks.callHook("close", nuxt),
+    close: async () => {
+      await hooks.callHook("close", nuxt);
+    },
     vfs: {},
     apps: {},
     runWithContext: (fn) => runWithNuxtContext(nuxt, fn),
@@ -5391,6 +6775,7 @@ const nightlies = {
 };
 let warnedAboutCompatDate = false;
 async function initNuxt(nuxt) {
+  nuxt._perf?.startPhase("init");
   const layerDirs = getLayerDirectories(nuxt);
   for (const config of nuxt.options._layers.map((layer) => layer.config).reverse()) {
     if (config.hooks) {
@@ -5473,7 +6858,7 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
       tsConfig: { compilerOptions: { paths: { ...paths } } }
     });
   });
-  const serverBuilderTypePath = typeof nuxt.options.server.builder === "string" ? nuxt.options.server.builder === "@nuxt/nitro-server" ? resolveModulePath(nuxt.options.server.builder, { from: import.meta.url }) : nuxt.options.server.builder : void 0;
+  const serverBuilderReference = typeof nuxt.options.server.builder === "string" ? nuxt.options.server.builder === "@nuxt/nitro-server" ? { path: resolveModulePath(nuxt.options.server.builder, { from: import.meta.url }).replace(".mjs", ".d.mts") } : { types: nuxt.options.server.builder } : void 0;
   nuxt.hook("prepare:types", async (opts) => {
     opts.references.push({ path: resolve(nuxt.options.buildDir, "types/plugins.d.ts") });
     if (nuxt.options.typescript.shim) {
@@ -5487,13 +6872,13 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
     opts.nodeReferences.push({ path: resolve(nuxt.options.buildDir, "types/runtime-config.d.ts") });
     opts.nodeReferences.push({ path: resolve(nuxt.options.buildDir, "types/app.config.d.ts") });
     opts.nodeReferences.push({ types: "nuxt" });
-    opts.nodeReferences.push({ types: relative(nuxt.options.buildDir, resolveModulePath("@nuxt/vite-builder", { from: import.meta.url })) });
+    opts.nodeReferences.push({ path: resolveModulePath("@nuxt/vite-builder", { from: import.meta.url }).replace(".mjs", ".d.mts") });
     if (typeof nuxt.options.builder === "string" && nuxt.options.builder !== "@nuxt/vite-builder") {
       opts.nodeReferences.push({ types: nuxt.options.builder });
     }
-    if (serverBuilderTypePath) {
-      opts.references.push({ types: serverBuilderTypePath });
-      opts.nodeReferences.push({ types: serverBuilderTypePath });
+    if (serverBuilderReference) {
+      opts.references.push(serverBuilderReference);
+      opts.nodeReferences.push(serverBuilderReference);
     }
     opts.sharedReferences.push({ path: resolve(nuxt.options.buildDir, "types/runtime-config.d.ts") });
     opts.sharedReferences.push({ path: resolve(nuxt.options.buildDir, "types/app.config.d.ts") });
@@ -5514,8 +6899,8 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
   nuxt.hook("nitro:prepare:types", (opts) => {
     opts.references.push({ path: resolve(nuxt.options.buildDir, "types/app.config.d.ts") });
     opts.references.push({ path: resolve(nuxt.options.buildDir, "types/runtime-config.d.ts") });
-    if (serverBuilderTypePath) {
-      opts.references.push({ types: serverBuilderTypePath });
+    if (serverBuilderReference) {
+      opts.references.push(serverBuilderReference);
     }
   });
   if (nuxt.options.scripts) {
@@ -5563,31 +6948,48 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
         composables: nuxt.options.optimization.treeShake.composables.client
       }), { server: false });
     }
-    const sharedDir = withTrailingSlash(resolve(nuxt.options.rootDir, nuxt.options.dir.shared));
-    const relativeSharedDir = withTrailingSlash(relative(nuxt.options.rootDir, resolve(nuxt.options.rootDir, nuxt.options.dir.shared)));
-    const sharedPatterns = [/^#shared\//, new RegExp("^" + escapeRE(sharedDir)), new RegExp("^" + escapeRE(relativeSharedDir))];
-    const sharedProtectionConfig = {
-      cwd: nuxt.options.rootDir,
-      include: sharedPatterns,
-      patterns: createImportProtectionPatterns(nuxt, { context: "shared" })
-    };
-    addBuildPlugin({
-      vite: () => ImpoundPlugin.vite(sharedProtectionConfig),
-      webpack: () => ImpoundPlugin.webpack(sharedProtectionConfig),
-      rspack: () => ImpoundPlugin.rspack(sharedProtectionConfig)
-    }, { server: false });
-    const nuxtProtectionConfig = {
-      cwd: nuxt.options.rootDir,
-      // Exclude top-level resolutions by plugins
-      exclude: [relative(nuxt.options.rootDir, join(nuxt.options.srcDir, "index.html")), ...sharedPatterns],
-      patterns: createImportProtectionPatterns(nuxt, { context: "nuxt-app" })
-    };
-    addBuildPlugin({
-      webpack: () => ImpoundPlugin.webpack(nuxtProtectionConfig),
-      rspack: () => ImpoundPlugin.rspack(nuxtProtectionConfig)
-    });
-    addVitePlugin(() => Object.assign(ImpoundPlugin.vite({ ...nuxtProtectionConfig, error: false }), { name: "nuxt:import-protection" }), { client: false });
-    addVitePlugin(() => Object.assign(ImpoundPlugin.vite({ ...nuxtProtectionConfig, error: true }), { name: "nuxt:import-protection" }), { server: false });
+    if (!nuxt.options.test) {
+      const sharedDir = withTrailingSlash(resolve(nuxt.options.rootDir, nuxt.options.dir.shared));
+      const relativeSharedDir = withTrailingSlash(relative(nuxt.options.rootDir, resolve(nuxt.options.rootDir, nuxt.options.dir.shared)));
+      const sharedPatterns = [/^#shared\//, new RegExp("^" + escapeRE(sharedDir)), new RegExp("^" + escapeRE(relativeSharedDir))];
+      const sharedProtectionConfig = {
+        cwd: nuxt.options.rootDir,
+        trace: true,
+        include: sharedPatterns,
+        patterns: createImportProtectionPatterns(nuxt, { context: "shared" })
+      };
+      addBuildPlugin({
+        vite: () => ImpoundPlugin.vite(sharedProtectionConfig),
+        webpack: () => ImpoundPlugin.webpack(sharedProtectionConfig),
+        rspack: () => ImpoundPlugin.rspack(sharedProtectionConfig)
+      }, { server: false, prepend: true });
+      const nuxtProtectionConfig = {
+        cwd: nuxt.options.rootDir,
+        trace: true,
+        // Exclude top-level resolutions by plugins
+        exclude: [relative(nuxt.options.rootDir, join(nuxt.options.srcDir, "index.html")), ...sharedPatterns],
+        patterns: createImportProtectionPatterns(nuxt, { context: "nuxt-app" })
+      };
+      addBuildPlugin({
+        webpack: () => ImpoundPlugin.webpack(nuxtProtectionConfig),
+        rspack: () => ImpoundPlugin.rspack(nuxtProtectionConfig)
+      });
+      for (const envOptions of [
+        { client: false },
+        { server: false }
+      ]) {
+        const error = envOptions.client === false ? false : true;
+        const vitePlugins = [ImpoundPlugin.vite({ ...nuxtProtectionConfig, error, ...error === false && { warn: "once" } })].flat().map((p) => Object.assign(p, { name: `nuxt:import-protection:${p.name}` }));
+        const mainPlugins = vitePlugins.filter((p) => !p.name.includes("trace"));
+        const tracePlugins = vitePlugins.filter((p) => p.name.includes("trace"));
+        if (mainPlugins.length) {
+          addVitePlugin(() => mainPlugins, { ...envOptions, prepend: true });
+        }
+        if (tracePlugins.length) {
+          addVitePlugin(() => tracePlugins, envOptions);
+        }
+      }
+    }
   });
   if (!nuxt.options.dev) {
     addBuildPlugin(DevOnlyPlugin({
@@ -5633,6 +7035,8 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
       nuxt.options.modulesDir.push(join(dirs.root, "node_modules"));
     }
   }
+  nuxt._perf?.endPhase("init");
+  nuxt._perf?.startPhase("modules");
   await nuxt.callHook("modules:before");
   const { paths: watchedModulePaths, resolvedModulePaths, modules } = await resolveModules(nuxt);
   nuxt.options.watch.push(...watchedModulePaths);
@@ -5700,6 +7104,13 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
     filePath: resolve(nuxt.options.appDir, "components/nuxt-route-announcer"),
     mode: "client"
   });
+  addComponent({
+    name: "NuxtAnnouncer",
+    priority: 10,
+    // built-in that we do not expect the user to override
+    filePath: resolve(nuxt.options.appDir, "components/nuxt-announcer"),
+    mode: "client"
+  });
   if (nuxt.options.experimental.clientFallback) {
     addComponent({
       name: "NuxtClientFallback",
@@ -5740,21 +7151,9 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
   await installModules(modules, resolvedModulePaths, nuxt);
   nuxt._ignore = ignore(nuxt.options.ignoreOptions);
   nuxt._ignore.add(resolveIgnorePatterns());
-  let unimport;
-  nuxt.hook("imports:context", (ctx) => {
-    unimport = ctx;
-  });
   await nuxt.callHook("modules:done");
-  const normalizedKeyedFunctions = await Promise.all(nuxt.options.optimization.keyedComposables.map(async ({ source, ...rest }) => ({
-    ...rest,
-    source: typeof source === "string" ? await resolvePath(source, { fallbackToOriginal: true }) ?? source : source
-  })));
-  addBuildPlugin(KeyedFunctionsPlugin({
-    sourcemap: !!nuxt.options.sourcemap.server || !!nuxt.options.sourcemap.client,
-    keyedFunctions: normalizedKeyedFunctions,
-    alias: nuxt.options.alias,
-    getAutoImports: unimport.getImports
-  }));
+  nuxt._perf?.endPhase("modules");
+  nuxt._perf?.collectModuleTimings(nuxt.options._installedModules);
   nuxt.options.css = nuxt.options.css.filter((value, index, array) => !array.includes(value, index + 1));
   if (nuxt.options.experimental.componentIslands) {
     addComponent({
@@ -5849,6 +7248,7 @@ export default defineNuxtPlugin({
   });
   addModuleTranspiles(nuxt);
   await bundleServer(nuxt);
+  nuxt._perf?.startPhase("ready");
   if (nuxt.options.experimental.payloadExtraction) {
     addPlugin(resolve(nuxt.options.appDir, "plugins/payload.client"));
   }
@@ -5856,9 +7256,21 @@ export default defineNuxtPlugin({
     logger.info(`Running with compatibility version \`${nuxt.options.future.compatibilityVersion}\``);
   }
   await nuxt.callHook("ready", nuxt);
+  nuxt._perf?.endPhase("ready");
 }
 async function loadNuxt(opts) {
+  let perf;
+  const cliStartTime = globalThis.__nuxt_cli__?.startTime;
+  const perfOverride = typeof opts.overrides?.debug === "object" && opts.overrides.debug.perf;
+  if (perfOverride) {
+    perf = new NuxtPerfProfiler({ startTime: cliStartTime });
+    perf.startPhase("config");
+  }
   const options = await loadNuxtConfig(opts);
+  if (!perf && typeof options.debug === "object" && options.debug.perf) {
+    perf = new NuxtPerfProfiler({ startTime: cliStartTime });
+  }
+  perf?.endPhase("config");
   options.appDir = options.alias["#app"] = withTrailingSlash(resolve(distDir, "app"));
   options._majorVersion = 4;
   for (const key in options.app.head || {}) {
@@ -5886,6 +7298,7 @@ async function loadNuxt(opts) {
     }
   }
   options._modules.push(pagesModule, metaModule, componentsModule);
+  options._modules.push(compilerModule);
   const importIncludes = [];
   for (const layer of options._layers) {
     if (layer.cwd && layer.cwd.includes("node_modules")) {
@@ -5934,6 +7347,29 @@ async function loadNuxt(opts) {
     }
   });
   const nuxt = createNuxt(options);
+  if (perf) {
+    nuxt._perf = perf;
+    perf.installHookInterceptors(nuxt.hooks);
+    const quiet = typeof options.debug === "object" && options.debug.perf === "quiet";
+    const title = nuxt.options.dev ? "Nuxt Performance Report" : "Nuxt Build Performance";
+    let flushed = false;
+    const flush = () => {
+      if (flushed || !perf) {
+        return;
+      }
+      flushed = true;
+      if (!quiet) {
+        perf.printReport({ title });
+      }
+      perf.writeReport(nuxt.options.buildDir, { quiet });
+      perf.dispose();
+    };
+    nuxt.hook("close", flush);
+    process.once("exit", flush);
+    nuxt.hook("close", () => {
+      process.off("exit", flush);
+    });
+  }
   nuxt.runWithContext(() => {
     if (opts.overrides?.hooks) {
       nuxt.hooks.addHooks(opts.overrides.hooks);
@@ -5942,6 +7378,9 @@ async function loadNuxt(opts) {
       createDebugger(nuxt.hooks, { tag: "nuxt" });
     }
   });
+  if (!nuxt.options._prepare && !nuxt.options.dev && nuxt.options.experimental.buildCache) {
+    nuxt.hooks.hookOnce("modules:before", () => restoreCachedBuildId(nuxt));
+  }
   if (opts.ready !== false) {
     await nuxt.ready();
   }
@@ -6510,7 +7949,7 @@ const nuxtConfigTemplate = {
     const shouldEnableComponentIslands = ctx.nuxt.options.experimental.componentIslands && (ctx.nuxt.options.dev || ctx.nuxt.options.experimental.componentIslands !== "auto" || ctx.app.pages?.some((p) => p.mode === "server") || ctx.app.components?.some((c) => c.mode === "server" && !ctx.app.components.some((other) => other.pascalName === c.pascalName && other.mode === "client")));
     const nitro = useNitro();
     const hasCachedRoutes = Object.values(nitro.options.routeRules).some((r) => r.isr || r.cache);
-    const payloadExtraction = !!ctx.nuxt.options.experimental.payloadExtraction && (nitro.options.static || hasCachedRoutes || nitro.options.prerender.routes.length > 0 || Object.values(nitro.options.routeRules).some((r) => r.prerender));
+    const payloadExtraction = !!ctx.nuxt.options.experimental.payloadExtraction && (nitro.options.static || hasCachedRoutes || nitro.options.prerender.routes && nitro.options.prerender.routes.length > 0 || Object.values(nitro.options.routeRules).some((r) => r.prerender));
     return [
       ...Object.entries(ctx.nuxt.options.app).map(([k, v]) => `export const ${camelCase("app-" + k)} = ${JSON.stringify(v)}`),
       `export const renderJsonPayloads = ${!!ctx.nuxt.options.experimental.renderJsonPayloads}`,
@@ -6525,6 +7964,7 @@ const nuxtConfigTemplate = {
       `export const devLogs = ${JSON.stringify(ctx.nuxt.options.features.devLogs)}`,
       `export const nuxtLinkDefaults = ${JSON.stringify(ctx.nuxt.options.experimental.defaults.nuxtLink)}`,
       `export const asyncDataDefaults = ${JSON.stringify(ctx.nuxt.options.experimental.defaults.useAsyncData)}`,
+      `export const useStateDefaults = ${JSON.stringify(ctx.nuxt.options.experimental.defaults.useState)}`,
       `export const fetchDefaults = ${JSON.stringify(fetchDefaults)}`,
       `export const vueAppRootContainer = ${ctx.nuxt.options.app.rootAttrs.id ? `'#${ctx.nuxt.options.app.rootAttrs.id}'` : `'body > ${ctx.nuxt.options.app.rootTag}'`}`,
       `export const viewTransition = ${ctx.nuxt.options.experimental.viewTransition}`,
@@ -6537,7 +7977,8 @@ const nuxtConfigTemplate = {
       `export const purgeCachedData = ${!!ctx.nuxt.options.experimental.purgeCachedData}`,
       `export const granularCachedData = ${!!ctx.nuxt.options.experimental.granularCachedData}`,
       `export const pendingWhenIdle = ${!!ctx.nuxt.options.experimental.pendingWhenIdle}`,
-      `export const alwaysRunFetchOnKeyChange = ${!!ctx.nuxt.options.experimental.alwaysRunFetchOnKeyChange}`
+      `export const alwaysRunFetchOnKeyChange = ${!!ctx.nuxt.options.experimental.alwaysRunFetchOnKeyChange}`,
+      `export const asyncCallHook = ${!!ctx.nuxt.options.experimental.asyncCallHook}`
     ].join("\n\n");
   }
 };
@@ -6647,9 +8088,9 @@ async function generateApp(nuxt, app, options = {}) {
       changedTemplates.push(template);
     }
     const perf = performance.now() - start;
-    const setupTime = Math.round(perf * 100) / 100;
-    if (nuxt.options.debug && nuxt.options.debug.templates || setupTime > 500) {
-      logger.info(`Compiled \`${template.filename}\` in ${setupTime}ms`);
+    const compileTime = Math.round(perf * 100) / 100;
+    if (nuxt.options.debug && nuxt.options.debug.templates || compileTime > 500) {
+      logger.info(`Compiled \`${template.filename}\` in ${compileTime}ms`);
     }
     if (template.modified && template.write) {
       dirs.add(dirname(fullPath));
@@ -6773,7 +8214,7 @@ async function annotatePlugins(nuxt, plugins) {
   const _plugins = [];
   for (const plugin of plugins) {
     try {
-      const code = plugin.src in nuxt.vfs ? nuxt.vfs[plugin.src] : await promises.readFile(plugin.src, "utf-8");
+      const code = nuxt.vfs[plugin.src] ?? await promises.readFile(plugin.src, "utf-8");
       _plugins.push({
         ...await extractMetadata(code, IS_TSX.test(plugin.src) ? "tsx" : "ts"),
         ...plugin
@@ -6831,29 +8272,29 @@ ${warningsAsList}`;
     logger.warn(warning);
   }
 }
-async function checkViteConfig() {
-  return await checkAndWarnAboutConfigFileExistence({
+function checkViteConfig() {
+  return checkAndWarnAboutConfigFileExistence({
     fileName: "vite.config",
     extensions: [".js", ".mjs", ".ts", ".cjs", ".mts", ".cts"],
     createWarningMessage: (foundFile) => `Using \`${foundFile}\` is not supported together with Nuxt. Use \`options.vite\` instead. You can read more in \`https://nuxt.com/docs/4.x/api/nuxt-config#vite\`.`
   });
 }
-async function checkWebpackConfig() {
-  return await checkAndWarnAboutConfigFileExistence({
+function checkWebpackConfig() {
+  return checkAndWarnAboutConfigFileExistence({
     fileName: "webpack.config",
     extensions: [".js", ".mjs", ".ts", ".cjs", ".mts", ".cts", "coffee"],
     createWarningMessage: (foundFile) => `Using \`${foundFile}\` is not supported together with Nuxt. Use \`options.webpack\` instead. You can read more in \`https://nuxt.com/docs/4.x/api/nuxt-config#webpack-1\`.`
   });
 }
-async function checkNitroConfig() {
-  return await checkAndWarnAboutConfigFileExistence({
+function checkNitroConfig() {
+  return checkAndWarnAboutConfigFileExistence({
     fileName: "nitro.config",
     extensions: [".ts", ".mts"],
     createWarningMessage: (foundFile) => `Using \`${foundFile}\` is not supported together with Nuxt. Use \`options.nitro\` instead. You can read more in \`https://nuxt.com/docs/4.x/api/nuxt-config#nitro\`.`
   });
 }
-async function checkPostCSSConfig() {
-  return await checkAndWarnAboutConfigFileExistence({
+function checkPostCSSConfig() {
+  return checkAndWarnAboutConfigFileExistence({
     fileName: "postcss.config",
     extensions: [".js", ".cjs"],
     createWarningMessage: (foundFile) => `Using \`${foundFile}\` is not supported together with Nuxt. Use \`options.postcss\` instead. You can read more in \`https://nuxt.com/docs/4.x/api/nuxt-config#postcss\`.`
@@ -6867,240 +8308,13 @@ async function checkAndWarnAboutConfigFileExistence(options) {
   }
 }
 
-async function getVueHash(nuxt) {
-  const id = "vue";
-  const { hash: hash2 } = await getHashes(nuxt, {
-    id,
-    cwd: (layer) => layer.config.srcDir || layer.cwd,
-    patterns: (layer) => {
-      const srcDir = layer.config.srcDir || layer.cwd;
-      return [
-        "**",
-        `!${relative(srcDir, layer.config.serverDir || join(layer.cwd, "server"))}/**`,
-        `!${relative(srcDir, resolve$1(layer.cwd, layer.config.dir?.public || "public"))}/**`,
-        "!node_modules/**",
-        "!nuxt.config.*"
-      ];
-    },
-    configOverrides: {
-      buildId: void 0,
-      serverDir: void 0,
-      nitro: void 0,
-      devServer: void 0,
-      runtimeConfig: void 0,
-      logLevel: void 0,
-      devServerHandlers: void 0,
-      devtools: void 0
-    }
-  });
-  const cacheFile = join(getCacheDir(nuxt), id, hash2 + ".tar");
-  return {
-    hash: hash2,
-    async collectCache() {
-      const start = Date.now();
-      await writeCache(nuxt.options.buildDir, nuxt.options.buildDir, cacheFile);
-      const elapsed = Date.now() - start;
-      consola.success(`Cached Vue client and server builds in \`${elapsed}ms\`.`);
-    },
-    async restoreCache() {
-      const start = Date.now();
-      const res = await restoreCache(nuxt.options.buildDir, cacheFile);
-      const elapsed = Date.now() - start;
-      if (res) {
-        consola.success(`Restored Vue client and server builds from cache in \`${elapsed}ms\`.`);
-      }
-      return res;
-    }
-  };
-}
-async function cleanupCaches(nuxt) {
-  const start = Date.now();
-  const caches = await glob(["*/*.tar"], {
-    cwd: getCacheDir(nuxt),
-    absolute: true
-  });
-  if (caches.length >= 10) {
-    const cachesWithMeta = await Promise.all(caches.map(async (cache) => {
-      return [cache, await stat(cache).then((r) => r.mtime.getTime()).catch(() => 0)];
-    }));
-    cachesWithMeta.sort((a, b) => a[1] - b[1]);
-    for (const [cache] of cachesWithMeta.slice(0, cachesWithMeta.length - 10)) {
-      await unlink(cache);
-    }
-    const elapsed = Date.now() - start;
-    consola.success(`Cleaned up old build caches in \`${elapsed}ms\`.`);
-  }
-}
-async function getHashes(nuxt, options) {
-  if (nuxt[`_${options.id}BuildHash`]) {
-    return nuxt[`_${options.id}BuildHash`];
-  }
-  const start = Date.now();
-  const hashSources = [];
-  let layerCtr = 0;
-  for (const layer of nuxt.options._layers) {
-    if (layer.cwd.includes("node_modules")) {
-      continue;
-    }
-    const layerName = `layer#${layerCtr++}`;
-    hashSources.push({
-      name: `${layerName}:config`,
-      data: serialize({
-        ...layer.config,
-        ...options.configOverrides || {}
-      })
-    });
-    const normalizeFiles = (files) => files.map((f) => ({
-      name: f.name,
-      size: f.attrs?.size,
-      data: hash(f.data)
-    })).sort((a, b) => a.name.localeCompare(b.name));
-    const isIgnored = createIsIgnored(nuxt);
-    const sourceFiles = await readFilesRecursive(options.cwd(layer), {
-      shouldIgnore: isIgnored,
-      // TODO: Validate if works with absolute paths
-      cwd: nuxt.options.rootDir,
-      patterns: options.patterns(layer)
-    });
-    hashSources.push({
-      name: `${layerName}:src`,
-      data: normalizeFiles(sourceFiles)
-    });
-    const rootFiles = await readFilesRecursive(layer.config?.rootDir || layer.cwd, {
-      shouldIgnore: isIgnored,
-      // TODO: Validate if works with absolute paths
-      cwd: nuxt.options.rootDir,
-      patterns: [
-        ".nuxtrc",
-        ".npmrc",
-        "package.json",
-        "package-lock.json",
-        "yarn.lock",
-        "pnpm-lock.yaml",
-        "tsconfig.json",
-        "bun.lock",
-        "bun.lockb"
-      ]
-    });
-    hashSources.push({
-      name: `${layerName}:root`,
-      data: normalizeFiles(rootFiles)
-    });
-  }
-  hashSources.sort((a, b) => a.name.localeCompare(b.name));
-  const res = nuxt[`_${options.id}BuildHash`] = {
-    hash: hash(hashSources),
-    sources: hashSources
-  };
-  const elapsed = Date.now() - start;
-  consola.debug(`Computed \`${options.id}\` build hash in \`${elapsed}ms\`.`);
-  return res;
-}
-async function readFilesRecursive(dir, opts) {
-  if (Array.isArray(dir)) {
-    return (await Promise.all(dir.map((d) => readFilesRecursive(d, opts)))).flat();
-  }
-  const files = await glob(opts.patterns, { cwd: dir });
-  const fileEntries = await Promise.all(files.map(async (fileName) => {
-    if (!opts.shouldIgnore?.(fileName)) {
-      const file = await readFileWithMeta(dir, fileName);
-      if (!file) {
-        return;
-      }
-      return {
-        ...file,
-        name: relative(opts.cwd, join(dir, file.name))
-      };
-    }
-  }));
-  return fileEntries.filter(Boolean);
-}
-async function readFileWithMeta(dir, fileName, count = 0) {
-  let fd = void 0;
-  try {
-    fd = await open(resolve$1(dir, fileName));
-    const stats = await fd.stat();
-    if (!stats?.isFile()) {
-      return;
-    }
-    const mtime = stats.mtime.getTime();
-    const data = await fd.readFile();
-    if ((await fd.stat()).mtime.getTime() !== mtime) {
-      if (count < 5) {
-        return readFileWithMeta(dir, fileName, count + 1);
-      }
-      console.warn(`Failed to read file \`${fileName}\` as it changed during read.`);
-      return;
-    }
-    return {
-      name: fileName,
-      data,
-      attrs: {
-        mtime,
-        size: stats.size
-      }
-    };
-  } catch (err) {
-    console.warn(`Failed to read file \`${fileName}\`:`, err);
-  } finally {
-    await fd?.close();
-  }
-}
-async function restoreCache(cwd, cacheFile) {
-  if (!existsSync(cacheFile)) {
-    return false;
-  }
-  const files = parseTar(await readFile(cacheFile));
-  for (const file of files) {
-    let fd = void 0;
-    try {
-      const filePath = resolve$1(cwd, file.name);
-      await mkdir(dirname(filePath), { recursive: true });
-      fd = await open(filePath, "w");
-      const stats = await fd.stat().catch(() => null);
-      if (stats?.isFile() && stats.size) {
-        const lastModified = Number.parseInt(file.attrs?.mtime?.toString().padEnd(13, "0") || "0");
-        if (stats.mtime.getTime() >= lastModified) {
-          consola.debug(`Skipping \`${file.name}\` (up to date or newer than cache)`);
-          continue;
-        }
-      }
-      await fd.writeFile(file.data);
-    } catch (err) {
-      console.error(err);
-    } finally {
-      await fd?.close();
-    }
-  }
-  return true;
-}
-async function writeCache(cwd, sources, cacheFile) {
-  const fileEntries = await readFilesRecursive(sources, {
-    patterns: ["**/*", "!analyze/**"],
-    cwd
-  });
-  const tarData = createTar(fileEntries);
-  await mkdir(dirname(cacheFile), { recursive: true });
-  await writeFile(cacheFile, tarData);
-}
-function getCacheDir(nuxt) {
-  let cacheDir = join(nuxt.options.workspaceDir, "node_modules");
-  if (!existsSync(cacheDir)) {
-    for (const dir of [...nuxt.options.modulesDir].sort((a, b) => a.length - b.length)) {
-      if (existsSync(dir)) {
-        cacheDir = dir;
-        break;
-      }
-    }
-  }
-  return join(cacheDir, ".cache/nuxt/builds");
-}
-
 async function build(nuxt) {
+  nuxt._perf?.startPhase("app:generate");
   const app = createApp(nuxt);
   nuxt.apps.default = app;
   const generateApp$1 = debounce(() => generateApp(nuxt, app), void 0, { leading: true });
   await generateApp$1();
+  nuxt._perf?.endPhase("app:generate");
   if (nuxt.options.dev) {
     watch(nuxt);
     nuxt.hook("builder:watch", async (event, relativePath) => {
@@ -7131,7 +8345,8 @@ async function build(nuxt) {
     const { restoreCache, collectCache } = await getVueHash(nuxt);
     if (await restoreCache()) {
       await nuxt.callHook("build:done");
-      return await nuxt.callHook("close", nuxt);
+      await nuxt.callHook("close", nuxt);
+      return;
     }
     nuxt.hooks.hookOnce("nitro:build:before", () => collectCache());
     nuxt.hooks.hookOnce("close", () => cleanupCaches(nuxt));
@@ -7146,7 +8361,9 @@ async function build(nuxt) {
       checkForExternalConfigurationFiles().catch((e) => logger.warn("Problem checking for external configuration files.", e));
     });
   }
+  nuxt._perf?.startPhase("build:bundle");
   await bundle(nuxt);
+  nuxt._perf?.endPhase("build:bundle");
   await nuxt.callHook("build:done");
   if (!nuxt.options.dev) {
     await nuxt.callHook("close", nuxt);
@@ -7172,7 +8389,15 @@ async function watch(nuxt) {
 function createWatcher() {
   const nuxt = useNuxt();
   const isIgnored2 = createIsIgnored(nuxt);
-  const watcher = watch$1(getLayerDirectories(nuxt).map((dirs) => dirs.app), {
+  const layerDirs = getLayerDirectories(nuxt);
+  const paths = [];
+  for (const layer of layerDirs) {
+    paths.push(layer.app);
+    if (!layer.server.startsWith(layer.app.replace(/\/?$/, "/"))) {
+      paths.push(layer.server);
+    }
+  }
+  const watcher = watch$1(paths, {
     ...nuxt.options.watchers.chokidar,
     ignoreInitial: true,
     ignored: [isIgnored2, /[\\/]node_modules[\\/]/]
@@ -7305,10 +8530,12 @@ async function loadBuilder(nuxt, builder) {
 function resolvePathsToWatch(nuxt, opts = {}) {
   const pathsToWatch = /* @__PURE__ */ new Set();
   for (const dirs of getLayerDirectories(nuxt)) {
-    if (!dirs.app || isIgnored(dirs.app)) {
-      continue;
+    if (!isIgnored(dirs.app)) {
+      pathsToWatch.add(dirs.app);
+    }
+    if (!isIgnored(dirs.server) && !dirs.server.startsWith(dirs.app.replace(/\/?$/, "/"))) {
+      pathsToWatch.add(dirs.server);
     }
-    pathsToWatch.add(dirs.app);
   }
   for (const pattern of nuxt.options.watch) {
     if (typeof pattern !== "string") {