@depup/nuxt 4.2.2-depup.0 → 4.3.0-depup.0

package/dist/index.mjs

@@ -1,22 +1,22 @@
 import process from 'node:process';
-import fs, { promises, existsSync, readdirSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
+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 { randomUUID } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { dirname, resolve, normalize, basename, extname, relative, isAbsolute, join } from 'pathe';
+import { dirname, resolve, normalize, basename, extname, relative, isAbsolute, join, 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, tryImportModule, runWithNuxtContext, nuxtCtx, loadNuxtConfig, addWebpackPlugin, installModules, resolveIgnorePatterns, addRouteMiddleware, resolveModuleWithOptions, normalizeTemplate, normalizePlugin } from '@nuxt/kit';
+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 { resolvePackageJSON, readPackage, readPackageJSON } from 'pkg-types';
 import { hash, isEqual, serialize } from 'ohash';
-import consola, { consola as consola$1 } from 'consola';
+import { consola } from 'consola';
 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, encodePath, withoutLeadingSlash } from 'ufo';
+import { withTrailingSlash as withTrailingSlash$1, parseURL, parseQuery, joinURL, withLeadingSlash, withoutLeadingSlash } from 'ufo';
 import { ImpoundPlugin } from 'impound';
-import defu$1, { defu } from 'defu';
+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';
@@ -25,7 +25,7 @@ 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 { toRouteMatcher, createRouter } from 'radix3';
+import { createRouter, addRoute, findAllRoutes } from 'rou3';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { runInNewContext } from 'node:vm';
 import { klona } from 'klona';
@@ -37,7 +37,7 @@ import { createUnplugin } from 'unplugin';
 import { findStaticImports, findExports, parseStaticImport, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
 import MagicString from 'magic-string';
 import { unheadVueComposablesImports } from '@unhead/vue';
-import { defineUnimportPreset, createUnimport, toExports, scanDirExports } from 'unimport';
+import { defineUnimportPreset, createUnimport, toExports, toTypeDeclarationFile, scanDirExports } from 'unimport';
 import { glob } from 'tinyglobby';
 import { parse, walk as walk$1, ELEMENT_NODE } from 'ultrahtml';
 import { isObject } from '@vue/shared';
@@ -56,9 +56,24 @@ import { parseTar, createTar } from 'nanotar';
 function toArray(value) {
   return Array.isArray(value) ? value : [value];
 }
-async function isDirectory$1(path) {
+async function isDirectory(path) {
   return (await promises.lstat(path)).isDirectory();
 }
+function isDirectorySync(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function stripExtension(path) {
+  return path.replace(/\.[^./\\]+$/, "");
+}
+function isWhitespace(char) {
+  const c = typeof char === "string" ? char.charCodeAt(0) : char;
+  return c === 32 || c === 9 || c === 10 || c === 13 || c === 12;
+}
+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()) {
   return reverseResolveAlias(path, { ...nuxt?.options.alias || {}, ...strippedAtAliases$1 }).pop() || path;
@@ -214,14 +229,6 @@ function getLoader(id) {
   }
   return ext.endsWith("x") ? "tsx" : "ts";
 }
-function matchWithStringOrRegex(value, matcher) {
-  if (typeof matcher === "string") {
-    return value === matcher;
-  } else if (matcher instanceof RegExp) {
-    return matcher.test(value);
-  }
-  return false;
-}
 
 function uniqueBy(arr, key) {
   if (arr.length < 2) {
@@ -307,6 +314,7 @@ function generateRoutesFromFiles(files, options = {}) {
       children: []
     };
     let parent = routes;
+    const routeGroups = [];
     const lastSegment = segments[segments.length - 1];
     if (lastSegment.endsWith(".server")) {
       segments[segments.length - 1] = lastSegment.replace(".server", "");
@@ -321,6 +329,8 @@ function generateRoutesFromFiles(files, options = {}) {
       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("");
@@ -337,6 +347,10 @@ function generateRoutesFromFiles(files, options = {}) {
         route.path += routePath;
       }
     }
+    if (routeGroups.length > 0) {
+      route.meta ||= {};
+      route.meta.groups = routeGroups;
+    }
     parent.push(route);
   }
   return prepareRoutes(routes);
@@ -483,7 +497,7 @@ function getRouteMeta(contents, absolutePath, extraExtractionKeys = /* @__PURE__
   extractCache[absolutePath] = extractedData;
   return klona(extractedData);
 }
-const COLON_RE = /:/g;
+const ESCAPE_CHARS_RE = /[\\:]/g;
 function getRoutePath(tokens, hasSucceedingSegment = false) {
   return tokens.reduce((path, token) => {
     switch (token.type) {
@@ -497,7 +511,7 @@ function getRoutePath(tokens, hasSucceedingSegment = false) {
         return path;
       case SegmentTokenType.static:
       default:
-        return path + encodePath(token.value).replace(COLON_RE, "\\:");
+        return path + token.value.replace(ESCAPE_CHARS_RE, "\\$&");
     }
   }, "/");
 }
@@ -855,212 +869,227 @@ const PageMetaPlugin = (options = {}) => createUnplugin(() => {
     transformInclude(id) {
       return !!parseMacroQuery(id).macro;
     },
-    transform(code, id) {
-      const query = parseMacroQuery(id);
-      if (query.type && query.type !== "script") {
-        return;
-      }
-      const s = new MagicString(code);
-      function result() {
-        if (s.hasChanged()) {
-          return {
-            code: s.toString(),
-            map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
-          };
-        }
-      }
-      const hasMacro = HAS_MACRO_RE.test(code);
-      const imports = findStaticImports(code);
-      const scriptImport = imports.find((i) => parseMacroQuery(i.specifier).type === "script");
-      if (scriptImport) {
-        const reorderedQuery = rewriteQuery(scriptImport.specifier);
-        const quotedSpecifier = getQuotedSpecifier(scriptImport.code)?.replace(scriptImport.specifier, reorderedQuery) ?? JSON.stringify(reorderedQuery);
-        s.overwrite(0, code.length, `export { default } from ${quotedSpecifier}`);
-        return result();
-      }
-      const currentExports = findExports(code);
-      for (const match of currentExports) {
-        if (match.type !== "default" || !match.specifier) {
-          continue;
-        }
-        const reorderedQuery = rewriteQuery(match.specifier);
-        const quotedSpecifier = getQuotedSpecifier(match.code)?.replace(match.specifier, reorderedQuery) ?? JSON.stringify(reorderedQuery);
-        s.overwrite(0, code.length, `export { default } from ${quotedSpecifier}`);
-        return result();
-      }
-      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));
-          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);
-        }
-        return result();
-      }
-      const importMap = /* @__PURE__ */ new Map();
-      const addedImports = /* @__PURE__ */ new Set();
-      for (const i of imports) {
-        const parsed = parseStaticImport(i);
-        for (const name of [
-          parsed.defaultImport,
-          ...Object.values(parsed.namedImports || {}),
-          parsed.namespacedImport
-        ].filter(Boolean)) {
-          importMap.set(name, i);
-        }
-      }
-      function isStaticIdentifier(name) {
-        return !!(name && importMap.has(name));
-      }
-      function addImport(name) {
-        if (!isStaticIdentifier(name)) {
-          return;
-        }
-        const importValue = importMap.get(name).code.trim();
-        if (!addedImports.has(importValue)) {
-          addedImports.add(importValue);
+    transform: {
+      filter: {
+        id: {
+          exclude: [/(?:\?|%3F).*type=(?:style|template)/]
+        },
+        code: {
+          include: [
+            HAS_MACRO_RE,
+            /\bfrom\s+["'][^"'?]*\?[^"']*type=script[^"']*["']/,
+            /export\s+\{\s*default\s*\}\s+from\s+["'][^"'?]*\?[^"']*type=script[^"']*["']/,
+            /^(?!.*__nuxt_page_meta)(?!.*export\s+\{\s*default\s*\})(?!.*\bdefinePageMeta\s*\()[\s\S]*$/
+          ]
         }
-      }
-      const declarationNodes = [];
-      const addedDeclarations = /* @__PURE__ */ new Set();
-      function addDeclaration(node) {
-        const codeSectionKey = `${resolveStart(node)}-${resolveEnd(node)}`;
-        if (addedDeclarations.has(codeSectionKey)) {
+      },
+      handler(code, id) {
+        const query = parseMacroQuery(id);
+        if (query.type && query.type !== "script") {
           return;
         }
-        addedDeclarations.add(codeSectionKey);
-        declarationNodes.push(node);
-      }
-      function addImportOrDeclaration(name, node) {
-        if (isStaticIdentifier(name)) {
-          addImport(name);
-        } else {
-          const declaration = scopeTracker.getDeclaration(name);
-          if (declaration && declaration !== node) {
-            processDeclaration(declaration);
+        const s = new MagicString(code);
+        function result() {
+          if (s.hasChanged()) {
+            return {
+              code: s.toString(),
+              map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
+            };
           }
         }
-      }
-      const scopeTracker = new ScopeTracker({
-        preserveExitedScopes: true
-      });
-      function processDeclaration(scopeTrackerNode) {
-        if (scopeTrackerNode?.type === "Variable") {
-          addDeclaration(scopeTrackerNode);
-          for (const decl of scopeTrackerNode.variableNode.declarations) {
-            if (!decl.init) {
-              continue;
-            }
-            walk(decl.init, {
-              enter: (node, parent) => {
-                if (node.type === "AwaitExpression") {
-                  logger.error(`Await expressions are not supported in definePageMeta. File: '${id}'`);
-                  throw new Error("await in definePageMeta");
-                }
-                if (isBindingIdentifier(node, parent) || node.type !== "Identifier") {
-                  return;
-                }
-                addImportOrDeclaration(node.name, scopeTrackerNode);
-              }
-            });
-          }
-        } else if (scopeTrackerNode?.type === "Function") {
-          if (scopeTrackerNode.node.type === "ArrowFunctionExpression") {
-            return;
+        const hasMacro = HAS_MACRO_RE.test(code);
+        const imports = findStaticImports(code);
+        const scriptImport = imports.find((i) => parseMacroQuery(i.specifier).type === "script");
+        if (scriptImport) {
+          const reorderedQuery = rewriteQuery(scriptImport.specifier);
+          const quotedSpecifier = getQuotedSpecifier(scriptImport.code)?.replace(scriptImport.specifier, reorderedQuery) ?? JSON.stringify(reorderedQuery);
+          s.overwrite(0, code.length, `export { default } from ${quotedSpecifier}`);
+          return result();
+        }
+        const currentExports = findExports(code);
+        for (const match of currentExports) {
+          if (match.type !== "default" || !match.specifier) {
+            continue;
           }
-          const name = scopeTrackerNode.node.id?.name;
-          if (!name) {
-            return;
+          const reorderedQuery = rewriteQuery(match.specifier);
+          const quotedSpecifier = getQuotedSpecifier(match.code)?.replace(match.specifier, reorderedQuery) ?? JSON.stringify(reorderedQuery);
+          s.overwrite(0, code.length, `export { default } from ${quotedSpecifier}`);
+          return result();
+        }
+        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));
+            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);
           }
-          addDeclaration(scopeTrackerNode);
-          const undeclaredIdentifiers = getUndeclaredIdentifiersInFunction(scopeTrackerNode.node);
-          for (const name2 of undeclaredIdentifiers) {
-            addImportOrDeclaration(name2);
+          return result();
+        }
+        const importMap = /* @__PURE__ */ new Map();
+        const addedImports = /* @__PURE__ */ new Set();
+        for (const i of imports) {
+          const parsed = parseStaticImport(i);
+          for (const name of [
+            parsed.defaultImport,
+            ...Object.values(parsed.namedImports || {}),
+            parsed.namespacedImport
+          ].filter(Boolean)) {
+            importMap.set(name, i);
           }
         }
-      }
-      const { program: ast } = parseAndWalk(code, id, {
-        scopeTracker,
-        parseOptions: {
-          lang: query.lang ?? "ts"
+        function isStaticIdentifier(name) {
+          return !!(name && importMap.has(name));
         }
-      });
-      scopeTracker.freeze();
-      let instances = 0;
-      walk(ast, {
-        scopeTracker,
-        enter: (node) => {
-          if (node.type !== "CallExpression" || node.callee.type !== "Identifier") {
+        function addImport(name) {
+          if (!isStaticIdentifier(name)) {
             return;
           }
-          if (!("name" in node.callee) || node.callee.name !== "definePageMeta") {
-            return;
+          const importValue = importMap.get(name).code.trim();
+          if (!addedImports.has(importValue)) {
+            addedImports.add(importValue);
           }
-          instances++;
-          const meta = node.arguments[0];
-          if (!meta) {
+        }
+        const declarationNodes = [];
+        const addedDeclarations = /* @__PURE__ */ new Set();
+        function addDeclaration(node) {
+          const codeSectionKey = `${resolveStart(node)}-${resolveEnd(node)}`;
+          if (addedDeclarations.has(codeSectionKey)) {
             return;
           }
-          const metaCode = code.slice(meta.start, meta.end);
-          const m = new MagicString(metaCode);
-          if (meta.type === "ObjectExpression") {
-            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)) {
-                const { serializable } = isSerializable(metaCode, prop.value);
-                if (!serializable) {
-                  continue;
-                }
-                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, "");
-                }
+          addedDeclarations.add(codeSectionKey);
+          declarationNodes.push(node);
+        }
+        function addImportOrDeclaration(name, node) {
+          if (isStaticIdentifier(name)) {
+            addImport(name);
+          } else {
+            const declaration = scopeTracker.getDeclaration(name);
+            if (declaration && declaration !== node) {
+              processDeclaration(declaration);
+            }
+          }
+        }
+        const scopeTracker = new ScopeTracker({
+          preserveExitedScopes: true
+        });
+        function processDeclaration(scopeTrackerNode) {
+          if (scopeTrackerNode?.type === "Variable") {
+            addDeclaration(scopeTrackerNode);
+            for (const decl of scopeTrackerNode.variableNode.declarations) {
+              if (!decl.init) {
+                continue;
               }
+              walk(decl.init, {
+                enter: (node, parent) => {
+                  if (node.type === "AwaitExpression") {
+                    logger.error(`Await expressions are not supported in definePageMeta. File: '${id}'`);
+                    throw new Error("await in definePageMeta");
+                  }
+                  if (isBindingIdentifier(node, parent) || node.type !== "Identifier") {
+                    return;
+                  }
+                  addImportOrDeclaration(node.name, scopeTrackerNode);
+                }
+              });
+            }
+          } else if (scopeTrackerNode?.type === "Function") {
+            if (scopeTrackerNode.node.type === "ArrowFunctionExpression") {
+              return;
+            }
+            const name = scopeTrackerNode.node.id?.name;
+            if (!name) {
+              return;
+            }
+            addDeclaration(scopeTrackerNode);
+            const undeclaredIdentifiers = getUndeclaredIdentifiersInFunction(scopeTrackerNode.node);
+            for (const name2 of undeclaredIdentifiers) {
+              addImportOrDeclaration(name2);
             }
           }
-          const definePageMetaScope = scopeTracker.getCurrentScope();
-          walk(meta, {
-            scopeTracker,
-            enter(node2, parent) {
-              if (isBindingIdentifier(node2, parent) || node2.type !== "Identifier") {
-                return;
+        }
+        const { program: ast } = parseAndWalk(code, id, {
+          scopeTracker,
+          parseOptions: {
+            lang: query.lang ?? "ts"
+          }
+        });
+        scopeTracker.freeze();
+        let instances = 0;
+        walk(ast, {
+          scopeTracker,
+          enter: (node) => {
+            if (node.type !== "CallExpression" || node.callee.type !== "Identifier") {
+              return;
+            }
+            if (!("name" in node.callee) || node.callee.name !== "definePageMeta") {
+              return;
+            }
+            instances++;
+            const meta = node.arguments[0];
+            if (!meta) {
+              return;
+            }
+            const metaCode = code.slice(meta.start, meta.end);
+            const m = new MagicString(metaCode);
+            if (meta.type === "ObjectExpression") {
+              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)) {
+                  const { serializable } = isSerializable(metaCode, prop.value);
+                  if (!serializable) {
+                    continue;
+                  }
+                  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, "");
+                  }
+                }
               }
-              const declaration = scopeTracker.getDeclaration(node2.name);
-              if (declaration) {
-                if (declaration.isUnderScope(definePageMetaScope) && (scopeTracker.isCurrentScopeUnder(declaration.scope) || resolveStart(declaration) < node2.start)) {
+            }
+            const definePageMetaScope = scopeTracker.getCurrentScope();
+            walk(meta, {
+              scopeTracker,
+              enter(node2, parent) {
+                if (isBindingIdentifier(node2, parent) || node2.type !== "Identifier") {
                   return;
                 }
+                const declaration = scopeTracker.getDeclaration(node2.name);
+                if (declaration) {
+                  if (declaration.isUnderScope(definePageMetaScope) && (scopeTracker.isCurrentScopeUnder(declaration.scope) || resolveStart(declaration) < node2.start)) {
+                    return;
+                  }
+                }
+                if (isStaticIdentifier(node2.name)) {
+                  addImport(node2.name);
+                } else if (declaration) {
+                  processDeclaration(declaration);
+                }
               }
-              if (isStaticIdentifier(node2.name)) {
-                addImport(node2.name);
-              } else if (declaration) {
-                processDeclaration(declaration);
-              }
-            }
-          });
-          const importStatements = Array.from(addedImports).join("\n");
-          const declarations = declarationNodes.sort((a, b) => resolveStart(a) - resolveStart(b)).map((node2) => code.slice(resolveStart(node2), resolveEnd(node2))).join("\n");
-          const extracted = [
-            importStatements,
-            declarations,
-            `const __nuxt_page_meta = ${m.toString() || "null"}
+            });
+            const importStatements = Array.from(addedImports).join("\n");
+            const declarations = declarationNodes.sort((a, b) => resolveStart(a) - resolveStart(b)).map((node2) => code.slice(resolveStart(node2), resolveEnd(node2))).join("\n");
+            const extracted = [
+              importStatements,
+              declarations,
+              `const __nuxt_page_meta = ${m.toString() || "null"}
 export default __nuxt_page_meta` + (options.dev ? CODE_HMR : "")
-          ].join("\n");
-          s.overwrite(0, code.length, extracted.trim());
+            ].join("\n");
+            s.overwrite(0, code.length, extracted.trim());
+          }
+        });
+        if (instances > 1) {
+          throw new Error("Multiple `definePageMeta` calls are not supported. File: " + id.replace(/\?.+$/, ""));
         }
-      });
-      if (instances > 1) {
-        throw new Error("Multiple `definePageMeta` calls are not supported. File: " + id.replace(/\?.+$/, ""));
-      }
-      if (!s.hasChanged() && !code.includes("__nuxt_page_meta")) {
-        s.overwrite(0, code.length, options.dev ? CODE_DEV_EMPTY + CODE_HMR : CODE_EMPTY);
+        if (!s.hasChanged() && !code.includes("__nuxt_page_meta")) {
+          s.overwrite(0, code.length, options.dev ? CODE_DEV_EMPTY + CODE_HMR : CODE_EMPTY);
+        }
+        return result();
       }
-      return result();
     },
     vite: {
       handleHotUpdate: {
@@ -1431,6 +1460,9 @@ const pagesModule = defineNuxtModule({
     const prerenderRoutes = /* @__PURE__ */ new Set();
     function processPages(pages, currentPath = "/") {
       for (const page of pages) {
+        if (page._sync) {
+          continue;
+        }
         if (OPTIONAL_PARAM_RE.test(page.path) && !page.children?.length) {
           prerenderRoutes.add(currentPath);
         }
@@ -1460,9 +1492,12 @@ const pagesModule = defineNuxtModule({
         ...toRou3Patterns(nuxt.apps.default?.pages || [])
       ];
       if (!nitro.options.static && !nitro.options.prerender.crawlLinks) {
-        const routeRulesMatcher = toRouteMatcher(createRouter({ routes: nitro.options.routeRules }));
+        const routeRulesRouter = createRouter();
+        for (const [route, rules] of Object.entries(nitro.options.routeRules)) {
+          addRoute(routeRulesRouter, void 0, route, rules);
+        }
         for (const route of prerenderRoutes) {
-          const rules = defu({}, ...routeRulesMatcher.matchAll(route).reverse());
+          const rules = defu({}, ...findAllRoutes(routeRulesRouter, void 0, route).reverse());
           if (rules.prerender) {
             nitro.options.prerender.routes.push(route);
           }
@@ -1497,26 +1532,24 @@ const pagesModule = defineNuxtModule({
         });
       });
     }
-    if (nuxt.options.experimental.appManifest) {
-      nuxt.hook("pages:extend", (routes) => {
-        const nitro = useNitro();
-        let resolvedRoutes;
-        for (const [path, rule] of Object.entries(nitro.options.routeRules)) {
-          if (!rule.redirect) {
-            continue;
-          }
-          resolvedRoutes ||= routes.flatMap((route) => resolveRoutePaths(route));
-          if (resolvedRoutes.includes(path)) {
-            continue;
-          }
-          routes.push({
-            _sync: true,
-            path: path.replace(/\/[^/]*\*\*/, "/:pathMatch(.*)"),
-            file: componentStubPath
-          });
+    nuxt.hook("pages:extend", (routes) => {
+      const nitro = useNitro();
+      let resolvedRoutes;
+      for (const [path, rule] of Object.entries(nitro.options.routeRules)) {
+        if (!rule.redirect) {
+          continue;
         }
-      });
-    }
+        resolvedRoutes ||= routes.flatMap((route) => resolveRoutePaths(route));
+        if (resolvedRoutes.includes(path)) {
+          continue;
+        }
+        routes.push({
+          _sync: true,
+          path: path.replace(/\/[^/]*\*\*/, "/:pathMatch(.*)"),
+          file: componentStubPath
+        });
+      }
+    });
     const extraPageMetaExtractionKeys = nuxt.options?.experimental?.extraPageMetaExtractionKeys || [];
     const extractedKeys = [
       ...defaultExtractionKeys,
@@ -1640,10 +1673,21 @@ 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'",
-          `export type LayoutKey = ${Object.keys(app.layouts).map((name) => genString(name)).join(" | ") || "string"}`,
           "declare module 'nuxt/app' {",
+          "  interface NuxtLayouts {",
+          ...Array.from(interfaceKeyValues.entries()).map(([key, value]) => `    '${key}': InstanceType<typeof ${value}>['$props'],`),
+          "}",
+          "  export type LayoutKey = keyof NuxtLayouts extends never ? string : keyof NuxtLayouts",
           "  interface PageMeta {",
           "    layout?: MaybeRef<LayoutKey | false> | ComputedRef<LayoutKey | false>",
           "  }",
@@ -1691,7 +1735,15 @@ if (import.meta.hot) {
       for (const route of routes) {
         router.addRoute(route)
       }
-      router.replace(router.currentRoute.value.fullPath)
+      router.isReady().then(() => {
+        // Resolve the current path against the new routes to get updated meta
+        const newRoute = router.resolve(router.currentRoute.value.fullPath)
+        // Clear old meta values and assign new ones
+        for (const key of Object.keys(router.currentRoute.value.meta)) {
+          delete router.currentRoute.value.meta[key]
+        }
+        Object.assign(router.currentRoute.value.meta, newRoute.meta)
+      })
     }
     if (routes && 'then' in routes) {
       routes.then(addRoutes)
@@ -2787,82 +2839,99 @@ function TransformPlugin$1(nuxt, options) {
       ];
     });
   }
-  return createUnplugin(() => ({
-    name: "nuxt:components:imports",
-    enforce: "post",
-    transformInclude(id) {
-      id = normalize(id);
-      return id.startsWith("virtual:") || id.startsWith("\0virtual:") || id.startsWith(nuxt.options.buildDir) || !isIgnored(id, void 0, nuxt);
+  return createUnplugin(() => [
+    {
+      name: "nuxt:components:imports-wrapper",
+      enforce: "post",
+      transformInclude(id) {
+        id = normalize(id);
+        return id.startsWith("virtual:") || id.startsWith("\0virtual:") || id.startsWith(nuxt.options.buildDir) || !isIgnored(id, void 0, nuxt);
+      },
+      transform: {
+        filter: {
+          id: COMPONENT_QUERY_RE
+        },
+        handler(_code, id) {
+          const { search } = parseURL(id);
+          const query = parseQuery$1(search);
+          const mode = query.nuxt_component;
+          const bare = id.replace(/\?.*/, "");
+          const componentExport = query.nuxt_component_export || "default";
+          const exportWording = componentExport === "default" ? "export default" : `export const ${componentExport} =`;
+          if (mode === "async") {
+            return {
+              code: [
+                'import { defineAsyncComponent } from "vue"',
+                `${exportWording} defineAsyncComponent(() => import(${JSON.stringify(bare)}).then(r => r[${JSON.stringify(componentExport)}] || r.default || r))`
+              ].join("\n"),
+              map: null
+            };
+          } else if (mode === "client") {
+            return {
+              code: [
+                genImport(bare, [{ name: componentExport, as: "__component" }]),
+                'import { createClientOnly } from "#app/components/client-only"',
+                `${exportWording} createClientOnly(__component)`
+              ].join("\n"),
+              map: null
+            };
+          } else if (mode === "client,async") {
+            return {
+              code: [
+                'import { defineAsyncComponent } from "vue"',
+                'import { createClientOnly } from "#app/components/client-only"',
+                `${exportWording} defineAsyncComponent(() => import(${JSON.stringify(bare)}).then(r => createClientOnly(r[${JSON.stringify(componentExport)}] || r.default || r)))`
+              ].join("\n"),
+              map: null
+            };
+          } else if (mode === "server" || mode === "server,async") {
+            const name = query.nuxt_component_name;
+            return {
+              code: [
+                `import { createServerComponent } from ${JSON.stringify(options.serverComponentRuntime)}`,
+                `${exportWording} createServerComponent(${JSON.stringify(name)})`
+              ].join("\n"),
+              map: null
+            };
+          } else {
+            throw new Error(`Unknown component mode: ${mode}, this might be an internal bug of Nuxt.`);
+          }
+        }
+      }
     },
-    async transform(code, id) {
-      if (COMPONENT_QUERY_RE.test(id)) {
-        const { search } = parseURL(id);
-        const query = parseQuery$1(search);
-        const mode = query.nuxt_component;
-        const bare = id.replace(/\?.*/, "");
-        const componentExport = query.nuxt_component_export || "default";
-        const exportWording = componentExport === "default" ? "export default" : `export const ${componentExport} =`;
-        if (mode === "async") {
-          return {
-            code: [
-              'import { defineAsyncComponent } from "vue"',
-              `${exportWording} defineAsyncComponent(() => import(${JSON.stringify(bare)}).then(r => r[${JSON.stringify(componentExport)}] || r.default || r))`
-            ].join("\n"),
-            map: null
-          };
-        } else if (mode === "client") {
-          return {
-            code: [
-              genImport(bare, [{ name: componentExport, as: "__component" }]),
-              'import { createClientOnly } from "#app/components/client-only"',
-              `${exportWording} createClientOnly(__component)`
-            ].join("\n"),
-            map: null
-          };
-        } else if (mode === "client,async") {
-          return {
-            code: [
-              'import { defineAsyncComponent } from "vue"',
-              'import { createClientOnly } from "#app/components/client-only"',
-              `${exportWording} defineAsyncComponent(() => import(${JSON.stringify(bare)}).then(r => createClientOnly(r[${JSON.stringify(componentExport)}] || r.default || r)))`
-            ].join("\n"),
-            map: null
-          };
-        } else if (mode === "server" || mode === "server,async") {
-          const name = query.nuxt_component_name;
+    {
+      name: "nuxt:components:imports-alias",
+      enforce: "post",
+      transformInclude(id) {
+        id = normalize(id);
+        return id.startsWith("virtual:") || id.startsWith("\0virtual:") || id.startsWith(nuxt.options.buildDir) || !isIgnored(id, void 0, nuxt);
+      },
+      transform: {
+        filter: {
+          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;
+          }
+          componentUnimport.modifyDynamicImports((imports) => {
+            imports.length = 0;
+            imports.push(...getComponentsImports());
+            return imports;
+          });
+          const result = await componentUnimport.injectImports(code, id, { autoImport: false, transformVirtualImports: true });
+          if (!result) {
+            return;
+          }
           return {
-            code: [
-              `import { createServerComponent } from ${JSON.stringify(options.serverComponentRuntime)}`,
-              `${exportWording} createServerComponent(${JSON.stringify(name)})`
-            ].join("\n"),
-            map: null
+            code: result.code,
+            map: nuxt.options.sourcemap.server || nuxt.options.sourcemap.client ? result.s.generateMap({ hires: true }) : void 0
           };
-        } else {
-          throw new Error(`Unknown component mode: ${mode}, this might be an internal bug of Nuxt.`);
         }
       }
-      if (!code.includes("#components")) {
-        return;
-      }
-      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;
-      }
-      componentUnimport.modifyDynamicImports((imports) => {
-        imports.length = 0;
-        imports.push(...getComponentsImports());
-        return imports;
-      });
-      const result = await componentUnimport.injectImports(code, id, { autoImport: false, transformVirtualImports: true });
-      if (!result) {
-        return;
-      }
-      return {
-        code: result.code,
-        map: nuxt.options.sourcemap.server || nuxt.options.sourcemap.client ? result.s.generateMap({ hires: true }) : void 0
-      };
     }
-  }));
+  ]);
 }
 
 const SSR_RENDER_RE = /ssrRenderComponent/;
@@ -3369,13 +3438,6 @@ function findImportExpression(node) {
 }
 
 const isPureObjectOrString = (val) => !Array.isArray(val) && typeof val === "object" || typeof val === "string";
-const isDirectory = (p) => {
-  try {
-    return statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-};
 const SLASH_SEPARATOR_RE = /[\\/]/;
 function compareDirByPathLength({ path: pathA }, { path: pathB }) {
   return pathB.split(SLASH_SEPARATOR_RE).filter(Boolean).length - pathA.split(SLASH_SEPARATOR_RE).filter(Boolean).length;
@@ -3425,7 +3487,7 @@ const componentsModule = defineNuxtModule({
         if (transpile) {
           nuxt.options.build.transpile.push(dirPath);
         }
-        const present = isDirectory(dirPath);
+        const present = isDirectorySync(dirPath);
         if (!present && !DEFAULT_COMPONENTS_DIRS_RE.test(dirOptions.path)) {
           logger.warn("Components directory not found: `" + dirPath + "`");
         }
@@ -3439,10 +3501,8 @@ const componentsModule = defineNuxtModule({
           ignore: [
             "**/*{M,.m,-m}ixin.{js,ts,jsx,tsx}",
             // ignore mixins
-            "**/*.d.{cts,mts,ts}",
+            `**/*.{${DECLARATION_EXTENSIONS.join(",")},}`,
             // .d.ts files
-            "**/*.d.vue.{cts,mts,ts}",
-            // .d.vue.ts files
             ...dirOptions.ignore || []
           ],
           transpile
@@ -3727,7 +3787,9 @@ const importsModule = defineNuxtModule({
     });
     nuxt.options.alias["#imports"] = join(nuxt.options.buildDir, "imports");
     addBuildPlugin(TransformPlugin({
-      ctx: { injectImports: (code, id, options2) => ctx.injectImports(code, id, options2) },
+      ctx: {
+        injectImports: (code, id, options2) => ctx.injectImports(code, id, options2)
+      },
       options,
       sourcemap: !!nuxt.options.sourcemap.server || !!nuxt.options.sourcemap.client
     }));
@@ -3814,7 +3876,7 @@ function addDeclarationTemplates(ctx, options) {
           return join(dir, name, subpath || "");
         }) ?? path;
       }
-      if (existsSync(path) && !await isDirectory$1(path)) {
+      if (existsSync(path) && !await isDirectory(path)) {
         path = path.replace(SUPPORTED_EXTENSION_RE, "");
       }
       if (isAbsolute(path)) {
@@ -3825,19 +3887,65 @@ function addDeclarationTemplates(ctx, options) {
   }
   addTypeTemplate({
     filename: "imports.d.ts",
-    getContents: async ({ nuxt: nuxt2 }) => toExports(await ctx.getImports(), nuxt2.options.buildDir, true)
+    getContents: async ({ nuxt: nuxt2 }) => toExports(await ctx.getImports(), nuxt2.options.buildDir, true, { declaration: true })
   });
+  const GENERATED_BY_COMMENT = "// Generated by auto imports\n";
+  const AUTO_IMPORTS_DISABLED_COMMENT = "// Implicit auto importing is disabled, you can explicitly import from `#imports` instead.\n";
   addTypeTemplate({
     filename: "types/imports.d.ts",
     getContents: async () => {
       const imports = await ctx.getImports();
       await cacheImportPaths(imports);
-      return "// Generated by auto imports\n" + (options.autoImport ? await ctx.generateTypeDeclarations({ resolvePath: r }) : "// Implicit auto importing is disabled, you can use explicitly import from `#imports` instead.");
+      return GENERATED_BY_COMMENT + (options.autoImport ? await ctx.generateTypeDeclarations({ resolvePath: r }) : AUTO_IMPORTS_DISABLED_COMMENT);
+    }
+  });
+  addTemplate({
+    filename: "types/shared-imports.d.ts",
+    getContents: async () => {
+      if (!options.autoImport) {
+        return GENERATED_BY_COMMENT + AUTO_IMPORTS_DISABLED_COMMENT;
+      }
+      const nitro = useNitro();
+      const nuxtImports = await ctx.getImports();
+      const nitroImports = await nitro.unimport?.getImports() ?? [];
+      const nitroImportsByName = new Map(nitroImports.map((i) => [i.as || i.name, i]));
+      const sharedImports = [];
+      for (const i of nuxtImports) {
+        const importName = i.as || i.name;
+        const nitroImport = nitroImportsByName.get(importName);
+        if (!nitroImport || i.dtsDisabled || nitroImport.dtsDisabled) {
+          continue;
+        }
+        sharedImports.push(i);
+      }
+      await cacheImportPaths(sharedImports);
+      return GENERATED_BY_COMMENT + toTypeDeclarationFile(sharedImports, { resolvePath: r });
     }
   });
 }
 
-const version = "4.2.2";
+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 = [];
@@ -3872,6 +3980,10 @@ function createImportProtectionPatterns(nuxt, options) {
       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;
 }
@@ -3893,7 +4005,11 @@ const UnctxTransformPlugin = (options) => createUnplugin(() => {
     },
     transform: {
       filter: {
-        code: { exclude: TRANSFORM_MARKER_RE }
+        ...transformer.filter,
+        code: {
+          ...transformer.filter.code,
+          exclude: TRANSFORM_MARKER_RE
+        }
       },
       handler(code) {
         if (!transformer.shouldTransform(code)) {
@@ -4013,6 +4129,7 @@ const DevOnlyPlugin = (options) => createUnplugin(() => {
 
 const ALIAS_RE = /(?<=['"])[~@]{1,2}(?=\/)/g;
 const ALIAS_RE_SINGLE = /(?<=['"])[~@]{1,2}(?=\/)/;
+const ALIAS_ID_RE = /^[~@]{1,2}\//;
 const LayerAliasingPlugin = (options) => createUnplugin((_options, meta) => {
   const aliases = {};
   for (const layer of options.layers) {
@@ -4026,19 +4143,46 @@ const LayerAliasingPlugin = (options) => createUnplugin((_options, meta) => {
     };
   }
   const layers = Object.keys(aliases).sort((a, b) => b.length - a.length);
-  return {
-    name: "nuxt:layer-aliasing",
-    enforce: "pre",
-    vite: {
-      resolveId: {
-        order: "pre",
-        async handler(id, importer) {
-          if (!importer) {
-            return;
-          }
-          const layer = layers.find((l) => importer.startsWith(l));
-          if (!layer) {
-            return;
+  const nonViteTransformIncludes = (id) => {
+    const _id = normalize(id);
+    return layers.some((dir) => _id.startsWith(dir));
+  };
+  const nonViteTransform = {
+    filter: {
+      code: { include: ALIAS_RE_SINGLE }
+    },
+    handler(code, id) {
+      const _id = normalize(id);
+      const layer = layers.find((l) => _id.startsWith(l));
+      if (!layer) {
+        return;
+      }
+      const s = new MagicString(code);
+      s.replace(ALIAS_RE, (r) => aliases[layer]?.[r] || r);
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
+        };
+      }
+    }
+  };
+  return {
+    name: "nuxt:layer-aliasing",
+    enforce: "pre",
+    vite: {
+      resolveId: {
+        order: "pre",
+        filter: {
+          id: ALIAS_ID_RE
+        },
+        async handler(id, importer) {
+          if (!importer) {
+            return;
+          }
+          const layer = layers.find((l) => importer.startsWith(l));
+          if (!layer) {
+            return;
           }
           const resolvedId = resolveAlias$1(id, aliases[layer]);
           if (resolvedId !== id) {
@@ -4048,36 +4192,8 @@ const LayerAliasingPlugin = (options) => createUnplugin((_options, meta) => {
       }
     },
     // webpack-only transform
-    transformInclude: (id) => {
-      if (meta.framework === "vite") {
-        return false;
-      }
-      const _id = normalize(id);
-      return layers.some((dir) => _id.startsWith(dir));
-    },
-    transform: {
-      filter: {
-        code: { include: ALIAS_RE_SINGLE }
-      },
-      handler(code, id) {
-        if (meta.framework === "vite") {
-          return;
-        }
-        const _id = normalize(id);
-        const layer = layers.find((l) => _id.startsWith(l));
-        if (!layer) {
-          return;
-        }
-        const s = new MagicString(code);
-        s.replace(ALIAS_RE, (r) => aliases[layer]?.[r] || r);
-        if (s.hasChanged()) {
-          return {
-            code: s.toString(),
-            map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
-          };
-        }
-      }
-    }
+    transformInclude: meta.framework !== "vite" ? nonViteTransformIncludes : void 0,
+    transform: meta.framework !== "vite" ? nonViteTransform : void 0
   };
 });
 
@@ -4118,7 +4234,7 @@ async function loadServerBuilder(nuxt, builder = "@nuxt/nitro-server") {
   try {
     return await importModule(builder, { url: [directoryToURL(nuxt.options.rootDir), new URL(import.meta.url)] });
   } catch (err) {
-    throw new Error(`Loading \`${builder}\` server builder failed.`, { cause: err });
+    throw new Error(`Loading \`${builder}\` server builder failed. You can read more about the nuxt \`server.builder\` option at: \`https://nuxt.com/docs/4.x/api/nuxt-config#builder-1\``, { cause: err });
   }
 }
 
@@ -4445,99 +4561,446 @@ const AsyncContextInjectionPlugin = (nuxt) => createUnplugin(() => {
   };
 });
 
+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;
+    }
+  }
+  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 [];
+}
+
 const stringTypes = ["Literal", "TemplateLiteral"];
-const NUXT_LIB_RE = /node_modules\/(?:nuxt|nuxt3|nuxt-nightly)\//;
+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 ComposableKeysPlugin = (options) => createUnplugin(() => {
-  const composableMeta = {};
-  const composableLengths = /* @__PURE__ */ new Set();
-  const keyedFunctions = /* @__PURE__ */ new Set();
-  for (const { name, ...meta } of options.composables) {
-    composableMeta[name] = meta;
-    keyedFunctions.add(name);
-    composableLengths.add(meta.argumentLength);
-  }
-  const maxLength = Math.max(...composableLengths);
-  const KEYED_FUNCTIONS_RE = new RegExp(`\\b(${[...keyedFunctions].map((f) => escapeRE(f)).join("|")})\\b`);
+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;
+}
+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.`);
+      }
+    }
+    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 CODE_INCLUDE_RE = new RegExp(`\\b(${[...namesToSourcesToFunctionMeta.keys(), ...defaultExportSources].map((f) => escapeRE(f)).join("|")})\\b`);
   return {
-    name: "nuxt:composable-keys",
+    name: "nuxt:compiler:keyed-functions",
     enforce: "post",
-    transformInclude(id) {
-      const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
-      return !NUXT_LIB_RE.test(pathname) && SUPPORTED_EXT_RE$1.test(pathname) && parseQuery(search).type !== "style" && !parseQuery(search).macro;
-    },
+    transformInclude: (id) => shouldTransformFile(id, SUPPORTED_EXT_RE$1),
     transform: {
       filter: {
-        code: { include: KEYED_FUNCTIONS_RE }
+        code: { include: CODE_INCLUDE_RE }
       },
-      handler(code, id) {
-        const { 0: script = code, index: codeIndex = 0 } = code.match(SCRIPT_RE$1) || { index: 0, 0: code };
+      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 imports;
         let count = 0;
-        const relativeID = isAbsolute(id) ? relative(options.rootDir, id) : id;
-        const { pathname: relativePathname } = parseURL(relativeID);
         const scopeTracker = new ScopeTracker({
           preserveExitedScopes: true
         });
-        const parseResult = parseAndWalk(script, id, {
-          scopeTracker
-        });
-        scopeTracker.freeze();
-        walk(parseResult.program, {
+        const { program } = parseAndWalk(code, _id, {
           scopeTracker,
           enter(node) {
-            if (node.type !== "CallExpression" || node.callee.type !== "Identifier") {
-              return;
-            }
-            const name = node.callee.name;
-            if (!name || !keyedFunctions.has(name) || node.arguments.length >= maxLength) {
+            if (!shouldConsiderExports) {
               return;
             }
-            imports ||= detectImportNames(script, composableMeta);
-            if (imports.has(name)) {
+            if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
               return;
             }
-            const meta = composableMeta[name];
-            const declaration = scopeTracker.getDeclaration(name);
-            if (declaration && declaration.type !== "Import") {
-              let skip = true;
-              if (meta.source) {
-                skip = !matchWithStringOrRegex(relativePathname, meta.source);
-              }
-              if (skip) {
-                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);
             }
-            if (node.arguments.length >= meta.argumentLength) {
+          }
+        });
+        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;
             }
-            switch (name) {
-              case "useState":
-                if (stringTypes.includes(node.arguments[0]?.type)) {
-                  return;
-                }
-                break;
-              case "useFetch":
-              case "useLazyFetch":
-                if (stringTypes.includes(node.arguments[1]?.type)) {
-                  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();
+            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;
+                  }
                 }
-                break;
-              case "useAsyncData":
-              case "useLazyAsyncData":
-                if (stringTypes.includes(node.arguments[0]?.type) || stringTypes.includes(node.arguments[node.arguments.length - 1]?.type)) {
+                if (wasKeyInjected) {
                   return;
                 }
-                break;
-            }
-            const newCode = code.slice(codeIndex + node.start, codeIndex + node.end - 1).trim();
-            const endsWithComma = newCode[newCode.length - 1] === ",";
-            s.appendLeft(
-              codeIndex + node.end - 1,
-              (node.arguments.length && !endsWithComma ? ", " : "") + "'$" + hash(`${relativeID}-${++count}`).slice(0, 10) + "'"
-            );
+              }
+              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()) {
@@ -4550,170 +5013,6 @@ const ComposableKeysPlugin = (options) => createUnplugin(() => {
     }
   };
 });
-const NUXT_IMPORT_RE = /nuxt|#app|#imports/;
-function detectImportNames(code, composableMeta) {
-  const names = /* @__PURE__ */ new Set();
-  function addName(name, specifier) {
-    const source = composableMeta[name]?.source;
-    if (source && matchWithStringOrRegex(specifier, source)) {
-      return;
-    }
-    names.add(name);
-  }
-  for (const i of findStaticImports(code)) {
-    if (NUXT_IMPORT_RE.test(i.specifier)) {
-      continue;
-    }
-    const { namedImports = {}, defaultImport, namespacedImport } = parseStaticImport(i);
-    for (const name in namedImports) {
-      addName(namedImports[name], i.specifier);
-    }
-    if (defaultImport) {
-      addName(defaultImport, i.specifier);
-    }
-    if (namespacedImport) {
-      addName(namespacedImport, i.specifier);
-    }
-  }
-  return names;
-}
-
-const VIRTUAL_RE = /^\0?virtual:(?:nuxt:)?/;
-function ResolveDeepImportsPlugin(nuxt) {
-  const exclude = ["virtual:", "\0virtual:", "/__skip_vite", "@vitest/"];
-  const conditions = {};
-  function resolveConditions(environment) {
-    const resolvedConditions = /* @__PURE__ */ new Set([nuxt.options.dev ? "development" : "production", ...environment.config.resolve.conditions]);
-    if (resolvedConditions.has("browser")) {
-      resolvedConditions.add("web");
-      resolvedConditions.add("import");
-      resolvedConditions.add("module");
-      resolvedConditions.add("default");
-    }
-    if (environment.config.mode === "test") {
-      resolvedConditions.add("import");
-      resolvedConditions.add("require");
-    }
-    return [...resolvedConditions];
-  }
-  return {
-    name: "nuxt:resolve-bare-imports",
-    enforce: "post",
-    async resolveId(id, importer) {
-      if (!importer || isAbsolute(id) || !isAbsolute(importer) && !VIRTUAL_RE.test(importer) || exclude.some((e) => id.startsWith(e))) {
-        return;
-      }
-      const normalisedId = resolveAlias$1(normalize(id), nuxt.options.alias);
-      const isNuxtTemplate = importer.startsWith("virtual:nuxt");
-      const normalisedImporter = (isNuxtTemplate ? decodeURIComponent(importer) : importer).replace(VIRTUAL_RE, "");
-      if (nuxt.options.experimental.templateImportResolution !== false && isNuxtTemplate) {
-        const template = nuxt.options.build.templates.find((t) => resolve(nuxt.options.buildDir, t.filename) === normalisedImporter);
-        if (template?._path) {
-          const res2 = await this.resolve?.(normalisedId, template._path, { skipSelf: true });
-          if (res2 !== void 0 && res2 !== null) {
-            return res2;
-          }
-        }
-      }
-      const dir = parseNodeModulePath(normalisedImporter).dir || pkgDir;
-      const res = await this.resolve?.(normalisedId, dir, { skipSelf: true });
-      if (res !== void 0 && res !== null) {
-        return res;
-      }
-      const environmentConditions = conditions[this.environment.name] ||= resolveConditions(this.environment);
-      const path = resolveModulePath(id, {
-        from: [dir, ...nuxt.options.modulesDir].map((d) => directoryToURL(d)),
-        suffixes: ["", "index"],
-        conditions: environmentConditions,
-        try: true
-      });
-      if (!path) {
-        logger.debug("Could not resolve id", id, importer);
-        return null;
-      }
-      return normalize(path);
-    }
-  };
-}
-
-const runtimeDependencies = [
-  // other deps
-  "devalue",
-  "klona",
-  // unjs ecosystem
-  "defu",
-  "ufo",
-  "h3",
-  "destr",
-  "consola",
-  "hookable",
-  "unctx",
-  "cookie-es",
-  "perfect-debounce",
-  "radix3",
-  "ohash",
-  "pathe",
-  "uncrypto"
-];
-
-function ResolveExternalsPlugin(nuxt) {
-  let external = /* @__PURE__ */ new Set();
-  const nitro = useNitro();
-  return {
-    name: "nuxt:resolve-externals",
-    enforce: "pre",
-    async config() {
-      const { runtimeDependencies: runtimeNitroDependencies = [] } = await tryImportModule("nitropack/runtime/meta", {
-        url: new URL(import.meta.url)
-      }) || {};
-      external = /* @__PURE__ */ new Set([
-        // explicit dependencies we use in our ssr renderer - these can be inlined (if necessary) in the nitro build
-        "unhead",
-        "@unhead/vue",
-        "@nuxt/devalue",
-        "rou3",
-        "unstorage",
-        // ensure we only have one version of vue if nitro is going to inline anyway
-        ...nitro.options.inlineDynamicImports ? ["vue", "@vue/server-renderer"] : [],
-        ...runtimeDependencies,
-        // dependencies we might share with nitro - these can be inlined (if necessary) in the nitro build
-        ...runtimeNitroDependencies
-      ]);
-      return {
-        optimizeDeps: {
-          exclude: Array.from(external)
-        }
-      };
-    },
-    applyToEnvironment(environment) {
-      if (nuxt.options.dev || environment.name !== "ssr") {
-        return false;
-      }
-      return {
-        name: "nuxt:resolve-externals:external",
-        async resolveId(id, importer) {
-          if (!external.has(id)) {
-            return;
-          }
-          const res = await this.resolve?.(id, importer, { skipSelf: true });
-          if (res !== void 0 && res !== null) {
-            if (res.id === id) {
-              res.id = resolveModulePath(res.id, {
-                try: true,
-                from: importer,
-                extensions: nuxt.options.extensions
-              }) || res.id;
-            }
-            return {
-              ...res,
-              external: "absolute"
-            };
-          }
-        }
-      };
-    }
-  };
-}
 
 function transformAndMinify(input, options) {
   const oxcOptions = tryUseNuxt()?.options.oxc;
@@ -4942,12 +5241,36 @@ const VirtualFSPlugin = (nuxt, options) => createUnplugin((_, meta) => {
       }
     }
   }
+  const relevantAliases = /* @__PURE__ */ new Set();
+  for (const key in alias) {
+    const value = alias[key];
+    if (value && Object.keys(nuxt.vfs).some((vfsPath) => vfsPath.startsWith(value))) {
+      relevantAliases.add(escapeDirectory(key));
+    }
+  }
+  const vfsEntries = /* @__PURE__ */ new Set();
+  for (const key in nuxt.vfs) {
+    if (!key.startsWith("#build/") && !key.startsWith(nuxt.options.buildDir)) {
+      vfsEntries.add(escapeDirectory(dirname(key)));
+    }
+  }
+  const filter = {
+    id: [
+      PREFIX_RE,
+      RELATIVE_ID_RE,
+      /^#build\//,
+      new RegExp("^(\\w:)?" + escapeDirectory(nuxt.options.buildDir)),
+      ...Array.from(vfsEntries).map((id) => new RegExp("^" + id)),
+      ...relevantAliases.size ? [new RegExp("^" + Array.from(relevantAliases).join("|") + "([\\\\/]|$)")] : []
+    ]
+  };
   return {
     name: "nuxt:virtual",
-    resolveId: meta.framework === "vite" ? void 0 : { order: "pre", handler: resolveId },
+    resolveId: meta.framework === "vite" ? void 0 : { order: "pre", filter, handler: resolveId },
     vite: {
       resolveId: {
         order: "pre",
+        filter,
         handler(id, importer) {
           const res = resolveId(id, importer);
           if (res) {
@@ -4959,15 +5282,17 @@ const VirtualFSPlugin = (nuxt, options) => createUnplugin((_, meta) => {
         }
       }
     },
-    loadInclude(id) {
-      return PREFIX_RE.test(id) && withoutQuery(withoutPrefix(decodeURIComponent(id))) in nuxt.vfs;
-    },
-    load(id) {
-      const key = withoutQuery(withoutPrefix(decodeURIComponent(id)));
-      return {
-        code: nuxt.vfs[key] || "",
-        map: null
-      };
+    load: {
+      filter: {
+        id: PREFIX_RE
+      },
+      handler(id) {
+        const key = withoutQuery(withoutPrefix(decodeURIComponent(id)));
+        return {
+          code: nuxt.vfs[key] || "",
+          map: null
+        };
+      }
     }
   };
 });
@@ -4978,6 +5303,9 @@ const QUERY_RE = /\?.*$/;
 function withoutQuery(id) {
   return id.replace(QUERY_RE, "");
 }
+function escapeDirectory(path) {
+  return escapeRE(path).replace(/\//g, "[\\\\/]");
+}
 
 function createNuxt(options) {
   const hooks = createHooks();
@@ -4987,7 +5315,7 @@ function createNuxt(options) {
   hooks.callHookWith = (...args) => runWithNuxtContext(nuxt, () => callHookWith(...args));
   const nuxt = {
     __name: randomUUID(),
-    _version: version,
+    _version: pkg.version,
     _asyncLocalStorageModule: options.experimental.debugModuleMutation ? new AsyncLocalStorage() : void 0,
     hooks,
     callHook: hooks.callHook,
@@ -5087,6 +5415,30 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
       }
     }
   });
+  addTypeTemplate({
+    filename: "types/nitro-layouts.d.ts",
+    getContents: ({ app }) => {
+      return [
+        `export type LayoutKey = ${Object.keys(app.layouts).map((name) => genString(name)).join(" | ") || "string"}`,
+        "declare module 'nitropack' {",
+        "  interface NitroRouteConfig {",
+        "    appLayout?: LayoutKey | false",
+        "  }",
+        "  interface NitroRouteRules {",
+        "    appLayout?: LayoutKey | false",
+        "  }",
+        "}",
+        "declare module 'nitropack/types' {",
+        "  interface NitroRouteConfig {",
+        "    appLayout?: LayoutKey | false",
+        "  }",
+        "  interface NitroRouteRules {",
+        "    appLayout?: LayoutKey | false",
+        "  }",
+        "}"
+      ].join("\n");
+    }
+  }, { nuxt: true, nitro: true, node: true });
   if (nuxt.options.typescript.builder !== false) {
     const envMap = {
       // defaults from `builder` based on package name
@@ -5113,10 +5465,11 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
   }
   const packageJSON = await readPackageJSON(nuxt.options.rootDir).catch(() => ({}));
   nuxt._dependencies = /* @__PURE__ */ new Set([...Object.keys(packageJSON.dependencies || {}), ...Object.keys(packageJSON.devDependencies || {})]);
+  nuxt["~runtimeDependencies"] = [...runtimeDependencies];
   let paths;
   nuxt.hook("nitro:config", async (nitroConfig) => {
     paths ||= await resolveTypescriptPaths(nuxt);
-    nitroConfig.typescript = defu$1(nitroConfig.typescript, {
+    nitroConfig.typescript = defu(nitroConfig.typescript, {
       tsConfig: { compilerOptions: { paths: { ...paths } } }
     });
   });
@@ -5144,10 +5497,11 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
     }
     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") });
+    opts.sharedReferences.push({ path: resolve(nuxt.options.buildDir, "types/shared-imports.d.ts") });
     paths ||= await resolveTypescriptPaths(nuxt);
-    opts.tsConfig.compilerOptions = defu$1(opts.tsConfig.compilerOptions, { paths: { ...paths } });
-    opts.nodeTsConfig.compilerOptions = defu$1(opts.nodeTsConfig.compilerOptions, { paths: { ...paths } });
-    opts.sharedTsConfig.compilerOptions = defu$1(opts.sharedTsConfig.compilerOptions, { paths: { ...paths } });
+    opts.tsConfig.compilerOptions = defu(opts.tsConfig.compilerOptions, { paths: { ...paths } });
+    opts.nodeTsConfig.compilerOptions = defu(opts.nodeTsConfig.compilerOptions, { paths: { ...paths } });
+    opts.sharedTsConfig.compilerOptions = defu(opts.sharedTsConfig.compilerOptions, { paths: { ...paths } });
     for (const dirs of layerDirs) {
       const declaration = join(dirs.root, "index.d.ts");
       if (existsSync(declaration)) {
@@ -5179,13 +5533,6 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
     }
   }), { server: false });
   addBuildPlugin(RemovePluginMetadataPlugin(nuxt));
-  addBuildPlugin(ComposableKeysPlugin({
-    sourcemap: !!nuxt.options.sourcemap.server || !!nuxt.options.sourcemap.client,
-    rootDir: nuxt.options.rootDir,
-    composables: nuxt.options.optimization.keyedComposables
-  }));
-  addVitePlugin(() => ResolveDeepImportsPlugin(nuxt));
-  addVitePlugin(() => ResolveExternalsPlugin(nuxt), { prepend: true });
   addBuildPlugin(PrehydrateTransformPlugin({ sourcemap: !!nuxt.options.sourcemap.server || !!nuxt.options.sourcemap.client }));
   if (nuxt.options.experimental.localLayerAliases) {
     addBuildPlugin(LayerAliasingPlugin({
@@ -5224,17 +5571,23 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
       include: sharedPatterns,
       patterns: createImportProtectionPatterns(nuxt, { context: "shared" })
     };
-    addVitePlugin(() => ImpoundPlugin.vite(sharedProtectionConfig), { server: false });
-    addWebpackPlugin(() => ImpoundPlugin.webpack(sharedProtectionConfig), { server: false });
+    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 });
-    addWebpackPlugin(() => ImpoundPlugin.webpack(nuxtProtectionConfig));
   });
   if (!nuxt.options.dev) {
     addBuildPlugin(DevOnlyPlugin({
@@ -5375,7 +5728,7 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
       _internal_install: "@nuxt/image"
     });
   }
-  if (nuxt.options.builder === "@nuxt/webpack-builder") {
+  if (nuxt.options.builder === "@nuxt/webpack-builder" || nuxt.options.builder === "@nuxt/rspack-builder") {
     addPlugin(resolve(nuxt.options.appDir, "plugins/preload.server"));
   }
   if (nuxt.options.debug && nuxt.options.debug.hooks && (nuxt.options.debug.hooks === true || nuxt.options.debug.hooks.client)) {
@@ -5387,7 +5740,21 @@ 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.options.css = nuxt.options.css.filter((value, index, array) => !array.includes(value, index + 1));
   if (nuxt.options.experimental.componentIslands) {
     addComponent({
@@ -5397,9 +5764,6 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
       filePath: resolve(nuxt.options.appDir, "components/nuxt-island")
     });
   }
-  if (!nuxt.options.dev && nuxt.options.experimental.payloadExtraction) {
-    addPlugin(resolve(nuxt.options.appDir, "plugins/payload.client"));
-  }
   if (nuxt.options.experimental.crossOriginPrefetch) {
     addPlugin(resolve(nuxt.options.appDir, "plugins/cross-origin-prefetch.client"));
   }
@@ -5419,12 +5783,12 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
     addPlugin(resolve(nuxt.options.appDir, "plugins/revive-payload.client"));
     addPlugin(resolve(nuxt.options.appDir, "plugins/revive-payload.server"));
   }
+  addRouteMiddleware({
+    name: "manifest-route-rule",
+    path: resolve(nuxt.options.appDir, "middleware/route-rules"),
+    global: true
+  });
   if (nuxt.options.experimental.appManifest) {
-    addRouteMiddleware({
-      name: "manifest-route-rule",
-      path: resolve(nuxt.options.appDir, "middleware/manifest-route-rule"),
-      global: true
-    });
     if (nuxt.options.experimental.checkOutdatedBuildInterval !== false) {
       addPlugin(resolve(nuxt.options.appDir, "plugins/check-outdated-build.client"));
     }
@@ -5485,14 +5849,7 @@ export default defineNuxtPlugin({
   });
   addModuleTranspiles(nuxt);
   await bundleServer(nuxt);
-  const nitro = useNitro();
-  if (nitro.options.static && nuxt.options.experimental.payloadExtraction === void 0) {
-    logger.warn("Using experimental payload extraction for full-static output. You can opt-out by setting `experimental.payloadExtraction` to `false`.");
-    nuxt.options.experimental.payloadExtraction = true;
-  }
-  nitro.options.replace["process.env.NUXT_PAYLOAD_EXTRACTION"] = String(!!nuxt.options.experimental.payloadExtraction);
-  nitro.options._config.replace["process.env.NUXT_PAYLOAD_EXTRACTION"] = String(!!nuxt.options.experimental.payloadExtraction);
-  if (!nuxt.options.dev && nuxt.options.experimental.payloadExtraction) {
+  if (nuxt.options.experimental.payloadExtraction) {
     addPlugin(resolve(nuxt.options.appDir, "plugins/payload.client"));
   }
   if (!satisfies(coerce(nuxt._version) ?? nuxt._version, nuxt.options.future.compatibilityVersion + ".x")) {
@@ -5516,7 +5873,7 @@ async function loadNuxt(opts) {
     }
   }
   if (!options._modules.some((m) => m === "@nuxt/scripts" || m === "@nuxt/scripts-nightly")) {
-    options.imports = defu$1(options.imports, {
+    options.imports = defu(options.imports, {
       presets: [scriptsStubsPreset]
     });
   }
@@ -5563,9 +5920,9 @@ async function loadNuxt(opts) {
       delete options.runtimeConfig.app[key];
     }
   }
-  createPortalProperties(options.nitro.runtimeConfig, options, ["nitro.runtimeConfig", "runtimeConfig"]);
-  createPortalProperties(options.nitro.routeRules, options, ["nitro.routeRules", "routeRules"]);
   const nitroOptions = options.nitro;
+  createPortalProperties(nitroOptions.runtimeConfig, options, ["nitro.runtimeConfig", "runtimeConfig"]);
+  createPortalProperties(nitroOptions.routeRules, options, ["nitro.routeRules", "routeRules"]);
   Object.defineProperties(options, {
     nitro: {
       configurable: false,
@@ -5679,8 +6036,8 @@ async function resolveModules(nuxt) {
 const NESTED_PKG_RE = /^[^@]+\//;
 async function resolveTypescriptPaths(nuxt) {
   nuxt.options.typescript.hoist ||= [];
-  const paths = Object.fromEntries(await Promise.all(nuxt.options.typescript.hoist.map(async (pkg) => {
-    const [_pkg = pkg, _subpath] = NESTED_PKG_RE.test(pkg) ? pkg.split("/") : [pkg];
+  const paths = Object.fromEntries(await Promise.all(nuxt.options.typescript.hoist.map(async (pkg2) => {
+    const [_pkg = pkg2, _subpath] = NESTED_PKG_RE.test(pkg2) ? pkg2.split("/") : [pkg2];
     const subpath = _subpath ? "/" + _subpath : "";
     if (nuxt._dependencies?.has(_pkg) && !(_pkg in nightlies)) {
       return [];
@@ -5689,12 +6046,12 @@ async function resolveTypescriptPaths(nuxt) {
       const nightly = nightlies[_pkg];
       const path2 = await resolveTypePath(nightly + subpath, subpath, nuxt.options.modulesDir);
       if (path2) {
-        return [[pkg, [path2]], [nightly + subpath, [path2]]];
+        return [[pkg2, [path2]], [nightly + subpath, [path2]]];
       }
     }
     const path = await resolveTypePath(_pkg + subpath, subpath, nuxt.options.modulesDir);
     if (path) {
-      return [[pkg, [path]]];
+      return [[pkg2, [path]]];
     }
     return [];
   })).then((r) => r.flat()));
@@ -5936,13 +6293,13 @@ const schemaNodeTemplate = {
           `     * Configuration for \`${importName}\``,
           ...options.addJSDocTags && link ? [`     * @see ${link}`] : [],
           `     */`,
-          `    [${configKey}]${options.unresolved ? "?" : ""}: typeof ${genDynamicImport(importName, { wrapper: false })}.default extends NuxtModule<infer O, unknown, boolean> ? ${options.unresolved ? "Partial<O>" : "O"} : Record<string, any>`
+          `    [${configKey}]${options.unresolved ? "?" : ""}: typeof ${genDynamicImport(importName, { wrapper: false })}.default extends NuxtModule<infer O, unknown, boolean> ? ${options.unresolved ? "Partial<O>" : "O"} | false : Record<string, any> | false`
         ];
       }),
       modules.length > 0 && options.unresolved ? `    modules?: (undefined | null | false | NuxtModule<any> | string | [NuxtModule | string, Record<string, any>] | ${modules.map(([configKey, importName, mod]) => `[${genString(mod.meta?.rawPath || importName)}, Exclude<NuxtConfig[${configKey}], boolean>]`).join(" | ")})[],` : ""
     ].filter(Boolean);
     const moduleDependencies = modules.flatMap(([_configKey, importName, mod]) => [
-      `    [${genString(mod.meta.name || importName)}]?: ModuleDependencyMeta<typeof ${genDynamicImport(importName, { wrapper: false })}.default extends NuxtModule<infer O> ? O : Record<string, unknown>>`
+      `    [${genString(mod.meta.name || importName)}]?: ModuleDependencyMeta<typeof ${genDynamicImport(importName, { wrapper: false })}.default extends NuxtModule<infer O> ? O | false : Record<string, unknown>> | false`
     ]).join("\n");
     return [
       "import { NuxtModule, ModuleDependencyMeta } from '@nuxt/schema'",
@@ -6151,11 +6508,14 @@ const nuxtConfigTemplate = {
       headers: void 0
     };
     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));
     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}`,
       `export const componentIslands = ${shouldEnableComponentIslands}`,
-      `export const payloadExtraction = ${!!ctx.nuxt.options.experimental.payloadExtraction}`,
+      `export const payloadExtraction = ${payloadExtraction}`,
       `export const cookieStore = ${!!ctx.nuxt.options.experimental.cookieStore}`,
       `export const appManifest = ${!!ctx.nuxt.options.experimental.appManifest}`,
       `export const remoteComponentIslands = ${typeof ctx.nuxt.options.experimental.componentIslands === "object" && ctx.nuxt.options.experimental.componentIslands.remoteIsland}`,
@@ -6172,7 +6532,7 @@ const nuxtConfigTemplate = {
       `export const outdatedBuildInterval = ${ctx.nuxt.options.experimental.checkOutdatedBuildInterval}`,
       `export const multiApp = ${!!ctx.nuxt.options.future.multiApp}`,
       `export const chunkErrorEvent = ${ctx.nuxt.options.experimental.emitRouteChunkError ? ctx.nuxt.options.builder === "@nuxt/vite-builder" ? '"vite:preloadError"' : '"nuxt:preloadError"' : "false"}`,
-      `export const crawlLinks = ${!!ctx.nuxt._nitro.options.prerender.crawlLinks}`,
+      `export const crawlLinks = ${!!nitro.options.prerender.crawlLinks}`,
       `export const spaLoadingTemplateOutside = ${ctx.nuxt.options.experimental.spaLoadingTemplateLocation === "body"}`,
       `export const purgeCachedData = ${!!ctx.nuxt.options.experimental.purgeCachedData}`,
       `export const granularCachedData = ${!!ctx.nuxt.options.experimental.granularCachedData}`,
@@ -6540,14 +6900,14 @@ async function getVueHash(nuxt) {
       const start = Date.now();
       await writeCache(nuxt.options.buildDir, nuxt.options.buildDir, cacheFile);
       const elapsed = Date.now() - start;
-      consola$1.success(`Cached Vue client and server builds in \`${elapsed}ms\`.`);
+      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$1.success(`Restored Vue client and server builds from cache in \`${elapsed}ms\`.`);
+        consola.success(`Restored Vue client and server builds from cache in \`${elapsed}ms\`.`);
       }
       return res;
     }
@@ -6568,7 +6928,7 @@ async function cleanupCaches(nuxt) {
       await unlink(cache);
     }
     const elapsed = Date.now() - start;
-    consola$1.success(`Cleaned up old build caches in \`${elapsed}ms\`.`);
+    consola.success(`Cleaned up old build caches in \`${elapsed}ms\`.`);
   }
 }
 async function getHashes(nuxt, options) {
@@ -6633,7 +6993,7 @@ async function getHashes(nuxt, options) {
     sources: hashSources
   };
   const elapsed = Date.now() - start;
-  consola$1.debug(`Computed \`${options.id}\` build hash in \`${elapsed}ms\`.`);
+  consola.debug(`Computed \`${options.id}\` build hash in \`${elapsed}ms\`.`);
   return res;
 }
 async function readFilesRecursive(dir, opts) {
@@ -6701,7 +7061,7 @@ async function restoreCache(cwd, cacheFile) {
       if (stats?.isFile() && stats.size) {
         const lastModified = Number.parseInt(file.attrs?.mtime?.toString().padEnd(13, "0") || "0");
         if (stats.mtime.getTime() >= lastModified) {
-          consola$1.debug(`Skipping \`${file.name}\` (up to date or newer than cache)`);
+          consola.debug(`Skipping \`${file.name}\` (up to date or newer than cache)`);
           continue;
         }
       }
@@ -6891,7 +7251,7 @@ async function createParcelWatcher() {
     const { subscribe } = await importModule("@parcel/watcher", { url: [nuxt.options.rootDir, ...nuxt.options.modulesDir].map((d) => directoryToURL(d)) });
     const pathsToWatch = resolvePathsToWatch(nuxt, { parentDirectories: true });
     for (const dir of pathsToWatch) {
-      if (!await isDirectory$1(dir)) {
+      if (!await isDirectory(dir)) {
         continue;
       }
       const watcher = subscribe(dir, (err, events) => {