@nuxt/kit 3.0.0-rc.8 → 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 - Nuxt Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -1,16 +1,13 @@
-import { Nuxt, ModuleContainer, ModuleOptions, ModuleDefinition, NuxtModule, NuxtConfig, NuxtOptions, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtTemplate, NuxtHooks, NuxtPlugin, NuxtPluginTemplate } from '@nuxt/schema';
+import { ModuleOptions, ModuleDefinition, NuxtModule, Nuxt, NuxtConfig, NuxtOptions, ImportPresetWithDeprecation, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtTemplate, NuxtHooks, NuxtPlugin, NuxtPluginTemplate, ResolvedNuxtTemplate } from '@nuxt/schema';
 import { LoadConfigOptions } from 'c12';
 import { Import } from 'unimport';
 import { Configuration, WebpackPluginInstance } from 'webpack';
 import { UserConfig, Plugin } from 'vite';
-import * as unctx from 'unctx';
-import { Middleware } from 'h3';
-import { NitroEventHandler, NitroDevEventHandler } from 'nitropack';
+import * as unctx_index from 'unctx/index';
+import { NitroEventHandler, NitroDevEventHandler, Nitro } from 'nitropack';
 import * as consola from 'consola';
 import { genSafeVariableName } from 'knitwork';
 
-declare function useModuleContainer(nuxt?: Nuxt): ModuleContainer;
-
 /**
  * Define a Nuxt module, automatically merging defaults with user provided options, installing
  * any hooks that are provided, and calling an optional setup function for full control.
@@ -37,8 +34,9 @@ interface LoadNuxtOptions extends LoadNuxtConfigOptions {
 declare function loadNuxt(opts: LoadNuxtOptions): Promise<Nuxt>;
 declare function buildNuxt(nuxt: Nuxt): Promise<any>;
 
-declare function addAutoImport(imports: Import | Import[]): void;
-declare function addAutoImportDir(_autoImportDirs: string | string[]): void;
+declare function addImports(imports: Import | Import[]): void;
+declare function addImportsDir(dirs: string | string[]): void;
+declare function addImportsSources(presets: ImportPresetWithDeprecation | ImportPresetWithDeprecation[]): void;
 
 interface ExtendConfigOptions {
     /**
@@ -67,13 +65,6 @@ interface ExtendConfigOptions {
     client?: boolean;
 }
 interface ExtendWebpackConfigOptions extends ExtendConfigOptions {
-    /**
-     * Install plugin on modern build
-     *
-     * @default true
-     * @deprecated Nuxt 2 only
-     */
-    modern?: boolean;
 }
 interface ExtendViteConfigOptions extends ExtendConfigOptions {
 }
@@ -87,15 +78,15 @@ declare function extendWebpackConfig(fn: ((config: Configuration) => void), opti
 /**
  * Extend Vite config
  */
-declare function extendViteConfig(fn: ((config: UserConfig) => void), options?: ExtendViteConfigOptions): () => void;
+declare function extendViteConfig(fn: ((config: UserConfig) => void), options?: ExtendViteConfigOptions): (() => void) | undefined;
 /**
  * Append Webpack plugin to the config.
  */
-declare function addWebpackPlugin(plugin: WebpackPluginInstance, options?: ExtendWebpackConfigOptions): void;
+declare function addWebpackPlugin(plugin: WebpackPluginInstance | WebpackPluginInstance[], options?: ExtendWebpackConfigOptions): void;
 /**
  * Append Vite plugin to the config.
  */
-declare function addVitePlugin(plugin: Plugin, options?: ExtendViteConfigOptions): void;
+declare function addVitePlugin(plugin: Plugin | Plugin[], options?: ExtendViteConfigOptions): void;
 
 /**
  * Check version constraints and return incompatibility issues as an array
@@ -128,7 +119,7 @@ declare function getNuxtVersion(nuxt?: Nuxt | any): any;
  * Requires Nuxt 2.13+
  */
 declare function addComponentsDir(dir: ComponentsDir): Promise<void>;
-declare type AddComponentOptions = {
+type AddComponentOptions = {
     name: string;
     filePath: string;
 } & Partial<Exclude<Component, 'shortPath' | 'async' | 'level' | 'import' | 'asyncImport'>>;
@@ -140,7 +131,7 @@ declare type AddComponentOptions = {
 declare function addComponent(opts: AddComponentOptions): Promise<void>;
 
 /** Direct access to the Nuxt context - see https://github.com/unjs/unctx. */
-declare const nuxtCtx: unctx.UseContext<Nuxt>;
+declare const nuxtCtx: unctx_index.UseContext<Nuxt>;
 /**
  * Get access to Nuxt instance.
  *
@@ -172,7 +163,7 @@ declare function tryUseNuxt(): Nuxt | null;
  */
 declare function isIgnored(pathname: string): boolean;
 
-declare function addLayout(tmpl: NuxtTemplate, name?: string): void;
+declare function addLayout(this: any, template: NuxtTemplate, name?: string): void;
 
 declare function extendPages(cb: NuxtHooks['pages:extend']): void;
 
@@ -228,7 +219,7 @@ declare function findPath(paths: string | string[], opts?: ResolvePathOptions, p
  */
 declare function resolveAlias(path: string, alias?: Record<string, string>): string;
 interface Resolver {
-    resolve(...path: any[]): string;
+    resolve(...path: string[]): string;
     resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
 }
 /**
@@ -239,18 +230,6 @@ declare function resolveFiles(path: string, pattern: string | string[], opts?: {
     followSymbolicLinks?: boolean;
 }): Promise<string[]>;
 
-interface LegacyServerMiddleware {
-    route?: string;
-    path?: string;
-    handle?: Middleware | string;
-    handler: Middleware | string;
-}
-/**
- * Adds a new server middleware to the end of the server middleware array.
- *
- * @deprecated Use addServerHandler instead
- */
-declare function addServerMiddleware(middleware: LegacyServerMiddleware): void;
 /**
  * Adds a nitro server handler
  *
@@ -261,54 +240,94 @@ declare function addServerHandler(handler: NitroEventHandler): void;
  *
  */
 declare function addDevServerHandler(handler: NitroDevEventHandler): void;
+/**
+ * Adds a Nitro plugin
+ */
+declare function addServerPlugin(plugin: string): void;
+/**
+ * Adds routes to be prerendered
+ */
+declare function addPrerenderRoutes(routes: string | string[]): void;
+/**
+ * Access to the Nitro instance
+ *
+ * **Note:** You can call `useNitro()` only after `ready` hook.
+ *
+ * **Note:** Changes to the Nitro instance configuration are not applied.
+ *
+ * @example
+ *
+ * ```ts
+ * nuxt.hook('ready', () => {
+ *   console.log(useNitro())
+ * })
+ * ```
+ */
+declare function useNitro(): Nitro;
 
 /**
  * Renders given template using lodash template during build into the project buildDir
  */
-declare function addTemplate(_template: NuxtTemplate | string): NuxtTemplate;
+declare function addTemplate(_template: NuxtTemplate<any> | string): ResolvedNuxtTemplate<any>;
 /**
  * Normalize a nuxt template object
  */
-declare function normalizeTemplate(template: NuxtTemplate | string): NuxtTemplate;
+declare function normalizeTemplate(template: NuxtTemplate<any> | string): ResolvedNuxtTemplate<any>;
+/**
+ * Trigger rebuilding Nuxt templates
+ *
+ * You can pass a filter within the options to selectively regenerate a subset of templates.
+ */
+declare function updateTemplates(options?: {
+    filter?: (template: ResolvedNuxtTemplate<any>) => boolean;
+}): Promise<any>;
 
 declare const logger: consola.Consola;
 declare function useLogger(scope?: string): consola.Consola;
 
+/** @deprecated Do not use CJS utils */
 interface ResolveModuleOptions {
     paths?: string | string[];
 }
+/** @deprecated Do not use CJS utils */
 interface RequireModuleOptions extends ResolveModuleOptions {
     /** Clear the require cache (force fresh require) but only if not within `node_modules` */
     clearCache?: boolean;
     /** Automatically de-default the result of requiring the module. */
     interopDefault?: boolean;
 }
+/** @deprecated Do not use CJS utils */
 declare function isNodeModules(id: string): boolean;
+/** @deprecated Do not use CJS utils */
 declare function clearRequireCache(id: string): void;
+/** @deprecated Do not use CJS utils */
 declare function scanRequireTree(id: string, files?: Set<string>): Set<string>;
-/** Access the require cache by module id. */
-declare function getRequireCacheItem(id: string): NodeModule;
+/** @deprecated Do not use CJS utils */
+declare function getRequireCacheItem(id: string): NodeModule | undefined;
 /** Resolve the `package.json` file for a given module. */
 declare function requireModulePkg(id: string, opts?: RequireModuleOptions): any;
-/** Resolve the path of a module. */
+/** @deprecated Do not use CJS utils */
 declare function resolveModule(id: string, opts?: ResolveModuleOptions): string;
-/** Try to resolve the path of a module, but don't emit an error if it can't be found. */
+/** @deprecated Do not use CJS utils */
 declare function tryResolveModule(path: string, opts?: ResolveModuleOptions): string | null;
-/** Require a module and return it. */
+/** @deprecated Do not use CJS utils */
 declare function requireModule(id: string, opts?: RequireModuleOptions): any;
+/** @deprecated Do not use CJS utils */
 declare function importModule(id: string, opts?: RequireModuleOptions): Promise<any>;
-declare function tryImportModule(id: string, opts?: RequireModuleOptions): Promise<any>;
-/** Try to require a module, but don't emit an error if the module can't be required. */
+/** @deprecated Do not use CJS utils */
+declare function tryImportModule(id: string, opts?: RequireModuleOptions): Promise<any> | undefined;
+/** @deprecated Do not use CJS utils */
 declare function tryRequireModule(id: string, opts?: RequireModuleOptions): any;
 
+/** @deprecated */
 declare function compileTemplate(template: NuxtTemplate, ctx: any): Promise<string>;
 /** @deprecated */
 declare const templateUtils: {
     serialize: (data: any) => string;
     importName: typeof genSafeVariableName;
     importSources: (sources: string | string[], { lazy }?: {
-        lazy?: boolean;
+        lazy?: boolean | undefined;
     }) => string;
 };
 
-export { AddComponentOptions, AddPluginOptions, ExtendConfigOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, LegacyServerMiddleware, LoadNuxtConfigOptions, LoadNuxtOptions, RequireModuleOptions, ResolveModuleOptions, ResolvePathOptions, Resolver, addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addDevServerHandler, addLayout, addPlugin, addPluginTemplate, addServerHandler, addServerMiddleware, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, useLogger, useModuleContainer, useNuxt };
+export { AddComponentOptions, AddPluginOptions, ExtendConfigOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, LoadNuxtConfigOptions, LoadNuxtOptions, RequireModuleOptions, ResolveModuleOptions, ResolvePathOptions, Resolver, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addServerHandler, addServerPlugin, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt };

package/dist/index.mjs

@@ -1,45 +1,27 @@
-import { parse, basename, resolve, relative, join, normalize, isAbsolute, dirname } from 'pathe';
-import { existsSync, readFileSync, promises } from 'node:fs';
-import hash from 'hash-sum';
+import { promises, existsSync, readFileSync } from 'node:fs';
+import defu from 'defu';
+import { applyDefaults } from 'untyped';
+import { dirname, join, normalize, relative, isAbsolute, resolve, basename, parse } from 'pathe';
+import consola from 'consola';
 import { getContext } from 'unctx';
-import { kebabCase, pascalCase } from 'scule';
 import satisfies from 'semver/functions/satisfies.js';
-import consola from 'consola';
+import lodashTemplate from 'lodash.template';
+import { genSafeVariableName, genDynamicImport, genImport } from 'knitwork';
 import { pathToFileURL, fileURLToPath } from 'node:url';
-import { globby } from 'globby';
 import { interopDefault } from 'mlly';
 import jiti from 'jiti';
+import { globby } from 'globby';
+import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
 import ignore from 'ignore';
-import defu from 'defu';
-import { applyDefaults } from 'untyped';
-import lodashTemplate from 'lodash.template';
-import { genSafeVariableName, genDynamicImport, genImport } from 'knitwork';
 import { loadConfig } from 'c12';
 import { NuxtConfigSchema } from '@nuxt/schema';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
+import { kebabCase, pascalCase } from 'scule';
+import hash from 'hash-sum';
 
-function chainFn(base, fn) {
-  if (typeof fn !== "function") {
-    return base;
-  }
-  return function(...args) {
-    if (typeof base !== "function") {
-      return fn.apply(this, args);
-    }
-    let baseResult = base.apply(this, args);
-    if (baseResult === void 0) {
-      [baseResult] = args;
-    }
-    const fnResult = fn.call(
-      this,
-      baseResult,
-      ...Array.prototype.slice.call(args, 1)
-    );
-    if (fnResult === void 0) {
-      return baseResult;
-    }
-    return fnResult;
-  };
+const logger = consola;
+function useLogger(scope) {
+  return scope ? logger.withScope(scope) : logger;
 }
 
 const nuxtCtx = getContext("nuxt");
@@ -54,53 +36,12 @@ function tryUseNuxt() {
   return nuxtCtx.tryUse();
 }
 
-function addTemplate(_template) {
-  const nuxt = useNuxt();
-  const template = normalizeTemplate(_template);
-  nuxt.options.build.templates = nuxt.options.build.templates.filter((p) => normalizeTemplate(p).filename !== template.filename);
-  nuxt.options.build.templates.push(template);
-  return template;
-}
-function normalizeTemplate(template) {
-  if (!template) {
-    throw new Error("Invalid template: " + JSON.stringify(template));
-  }
-  if (typeof template === "string") {
-    template = { src: template };
-  } else {
-    template = { ...template };
-  }
-  if (template.src) {
-    if (!existsSync(template.src)) {
-      throw new Error("Template not found: " + template.src);
-    }
-    if (!template.filename) {
-      const srcPath = parse(template.src);
-      template.filename = template.fileName || `${basename(srcPath.dir)}.${srcPath.name}.${hash(template.src)}${srcPath.ext}`;
-    }
-  }
-  if (!template.src && !template.getContents) {
-    throw new Error("Invalid template. Either getContents or src options should be provided: " + JSON.stringify(template));
-  }
-  if (!template.filename) {
-    throw new Error("Invalid template. Either filename should be provided: " + JSON.stringify(template));
-  }
-  if (template.filename.endsWith(".d.ts")) {
-    template.write = true;
-  }
-  if (!template.dst) {
-    const nuxt = useNuxt();
-    template.dst = resolve(nuxt.options.buildDir, template.filename);
-  }
-  return template;
-}
-
 async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
   const issues = [];
   if (constraints.nuxt) {
     const nuxtVersion = getNuxtVersion(nuxt);
-    const nuxtSemanticVersion = nuxtVersion.split("-").shift();
-    if (!satisfies(nuxtSemanticVersion, constraints.nuxt)) {
+    const nuxtSemanticVersion = nuxtVersion.replace(/-[0-9]+\.[0-9a-f]{7,8}/, "");
+    if (!satisfies(nuxtSemanticVersion, constraints.nuxt, { includePrerelease: true })) {
       issues.push({
         name: "nuxt",
         message: `Nuxt version \`${constraints.nuxt}\` is required but currently using \`${nuxtVersion}\``
@@ -151,59 +92,125 @@ function getNuxtVersion(nuxt = useNuxt()) {
   return version;
 }
 
-const logger = consola;
-function useLogger(scope) {
-  return scope ? logger.withScope(scope) : logger;
+async function compileTemplate(template, ctx) {
+  const data = { ...ctx, options: template.options };
+  if (template.src) {
+    try {
+      const srcContents = await promises.readFile(template.src, "utf-8");
+      return lodashTemplate(srcContents, {})(data);
+    } catch (err) {
+      console.error("Error compiling template: ", template);
+      throw err;
+    }
+  }
+  if (template.getContents) {
+    return template.getContents(data);
+  }
+  throw new Error("Invalid template: " + JSON.stringify(template));
 }
+const serialize = (data) => JSON.stringify(data, null, 2).replace(/"{(.+)}"(?=,?$)/gm, (r) => JSON.parse(r).replace(/^{(.*)}$/, "$1"));
+const importSources = (sources, { lazy = false } = {}) => {
+  if (!Array.isArray(sources)) {
+    sources = [sources];
+  }
+  return sources.map((src) => {
+    if (lazy) {
+      return `const ${genSafeVariableName(src)} = ${genDynamicImport(src, { comment: `webpackChunkName: ${JSON.stringify(src)}` })}`;
+    }
+    return genImport(src, genSafeVariableName(src));
+  }).join("\n");
+};
+const importName = genSafeVariableName;
+const templateUtils = { serialize, importName, importSources };
 
-function addLayout(tmpl, name) {
-  const nuxt = useNuxt();
-  const { filename, src } = addTemplate(tmpl);
-  const layoutName = kebabCase(name || parse(tmpl.filename).name).replace(/["']/g, "");
-  if (isNuxt2(nuxt)) {
-    const layout = nuxt.options.layouts[layoutName];
-    if (layout) {
-      return logger.warn(
-        `Not overriding \`${layoutName}\` (provided by \`${layout}\`) with \`${src || filename}\`.`
-      );
+function defineNuxtModule(definition) {
+  if (!definition.meta) {
+    definition.meta = {};
+  }
+  if (definition.meta.configKey === void 0) {
+    definition.meta.configKey = definition.meta.name;
+  }
+  async function getOptions(inlineOptions, nuxt = useNuxt()) {
+    const configKey = definition.meta.configKey || definition.meta.name;
+    const _defaults = definition.defaults instanceof Function ? definition.defaults(nuxt) : definition.defaults;
+    let _options = defu(inlineOptions, nuxt.options[configKey], _defaults);
+    if (definition.schema) {
+      _options = await applyDefaults(definition.schema, _options);
     }
-    nuxt.options.layouts[layoutName] = `./${filename}`;
-    if (name === "error") {
-      this.addErrorLayout(filename);
+    return Promise.resolve(_options);
+  }
+  async function normalizedModule(inlineOptions, nuxt) {
+    if (!nuxt) {
+      nuxt = tryUseNuxt() || this.nuxt;
+    }
+    const uniqueKey = definition.meta.name || definition.meta.configKey;
+    if (uniqueKey) {
+      nuxt.options._requiredModules = nuxt.options._requiredModules || {};
+      if (nuxt.options._requiredModules[uniqueKey]) {
+        return;
+      }
+      nuxt.options._requiredModules[uniqueKey] = true;
     }
+    if (definition.meta.compatibility) {
+      const issues = await checkNuxtCompatibility(definition.meta.compatibility, nuxt);
+      if (issues.length) {
+        logger.warn(`Module \`${definition.meta.name}\` is disabled due to incompatibility issues:
+${issues.toString()}`);
+        return;
+      }
+    }
+    nuxt2Shims(nuxt);
+    const _options = await getOptions(inlineOptions, nuxt);
+    if (definition.hooks) {
+      nuxt.hooks.addHooks(definition.hooks);
+    }
+    await definition.setup?.call(null, _options, nuxt);
+  }
+  normalizedModule.getMeta = () => Promise.resolve(definition.meta);
+  normalizedModule.getOptions = getOptions;
+  return normalizedModule;
+}
+const NUXT2_SHIMS_KEY = "__nuxt2_shims_key__";
+function nuxt2Shims(nuxt) {
+  if (!isNuxt2(nuxt) || nuxt[NUXT2_SHIMS_KEY]) {
     return;
   }
-  nuxt.hook("app:templates", (app) => {
-    if (layoutName in app.layouts) {
-      const relativePath = relative(nuxt.options.srcDir, app.layouts[layoutName].file);
-      return logger.warn(
-        `Not overriding \`${layoutName}\` (provided by \`~/${relativePath}\`) with \`${src || filename}\`.`
-      );
+  nuxt[NUXT2_SHIMS_KEY] = true;
+  nuxt.hooks = nuxt;
+  if (!nuxtCtx.tryUse()) {
+    nuxtCtx.set(nuxt);
+    nuxt.hook("close", () => nuxtCtx.unset());
+  }
+  let virtualTemplates;
+  nuxt.hook("builder:prepared", (_builder, buildOptions) => {
+    virtualTemplates = buildOptions.templates.filter((t) => t.getContents);
+    for (const template of virtualTemplates) {
+      buildOptions.templates.splice(buildOptions.templates.indexOf(template), 1);
     }
-    app.layouts[layoutName] = {
-      file: join("#build", filename),
-      name: layoutName
+  });
+  nuxt.hook("build:templates", async (templates) => {
+    const context = {
+      nuxt,
+      utils: templateUtils,
+      app: {
+        dir: nuxt.options.srcDir,
+        extensions: nuxt.options.extensions,
+        plugins: nuxt.options.plugins,
+        templates: [
+          ...templates.templatesFiles,
+          ...virtualTemplates
+        ],
+        templateVars: templates.templateVars
+      }
     };
+    for await (const template of virtualTemplates) {
+      const contents = await compileTemplate({ ...template, src: "" }, context);
+      await promises.mkdir(dirname(template.dst), { recursive: true });
+      await promises.writeFile(template.dst, contents);
+    }
   });
 }
 
-function normalizeHandlerMethod(handler) {
-  const [, method = void 0] = handler.handler.match(/\.(get|head|patch|post|put|delete|connect|options|trace)(\.\w+)*$/) || [];
-  return {
-    method,
-    ...handler
-  };
-}
-function addServerMiddleware(middleware) {
-  useNuxt().options.serverMiddleware.push(middleware);
-}
-function addServerHandler(handler) {
-  useNuxt().options.serverHandlers.push(normalizeHandlerMethod(handler));
-}
-function addDevServerHandler(handler) {
-  useNuxt().options.devServerHandlers.push(handler);
-}
-
 const _require = jiti(process.cwd(), { interopDefault: true, esmResolve: true });
 function isNodeModules(id) {
   return /[/\\]node_modules[/\\]/.test(id);
@@ -253,7 +260,7 @@ function resolveModule(id, opts = {}) {
   return normalize(_require.resolve(id, {
     paths: [].concat(
       global.__NUXT_PREPATHS__,
-      opts.paths,
+      opts.paths || [],
       process.cwd(),
       global.__NUXT_PATHS__
     ).filter(Boolean)
@@ -263,7 +270,7 @@ function tryResolveModule(path, opts = {}) {
   try {
     return resolveModule(path, opts);
   } catch (error) {
-    if (error.code !== "MODULE_NOT_FOUND") {
+    if (error?.code !== "MODULE_NOT_FOUND") {
       throw error;
     }
   }
@@ -300,7 +307,7 @@ function tryRequireModule(id, opts = {}) {
 function isIgnored(pathname) {
   const nuxt = tryUseNuxt();
   if (!nuxt) {
-    return null;
+    return false;
   }
   if (!nuxt._ignore) {
     nuxt._ignore = ignore(nuxt.options.ignoreOptions);
@@ -314,7 +321,7 @@ function isIgnored(pathname) {
   if (relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath && nuxt._ignore.ignores(relativePath);
+  return !!(relativePath && nuxt._ignore.ignores(relativePath));
 }
 
 async function resolvePath(path, opts = {}) {
@@ -323,7 +330,7 @@ async function resolvePath(path, opts = {}) {
   if (isAbsolute(path) && existsSync(path) && !await isDirectory(path)) {
     return path;
   }
-  const nuxt = useNuxt();
+  const nuxt = tryUseNuxt();
   const cwd = opts.cwd || (nuxt ? nuxt.options.rootDir : process.cwd());
   const extensions = opts.extensions || (nuxt ? nuxt.options.extensions : [".ts", ".mjs", ".cjs", ".json"]);
   const modulesDir = nuxt ? nuxt.options.modulesDir : [];
@@ -373,15 +380,7 @@ function resolveAlias(path, alias) {
   if (!alias) {
     alias = tryUseNuxt()?.options.alias || {};
   }
-  for (const key in alias) {
-    if (key === "@" && !path.startsWith("@/")) {
-      continue;
-    }
-    if (path.startsWith(key)) {
-      path = alias[key] + path.slice(key.length);
-    }
-  }
-  return path;
+  return resolveAlias$1(path, alias);
 }
 function createResolver(base) {
   if (!base) {
@@ -411,41 +410,13 @@ async function resolveFiles(path, pattern, opts = {}) {
   return files.map((p) => resolve(path, p)).filter((p) => !isIgnored(p)).sort();
 }
 
-function normalizePlugin(plugin) {
-  if (typeof plugin === "string") {
-    plugin = { src: plugin };
-  } else {
-    plugin = { ...plugin };
-  }
-  if (!plugin.src) {
-    throw new Error("Invalid plugin. src option is required: " + JSON.stringify(plugin));
-  }
-  plugin.src = normalize(resolveAlias(plugin.src));
-  if (plugin.ssr) {
-    plugin.mode = "server";
-  }
-  if (!plugin.mode) {
-    const [, mode = "all"] = plugin.src.match(/\.(server|client)(\.\w+)*$/) || [];
-    plugin.mode = mode;
-  }
-  return plugin;
-}
-function addPlugin(_plugin, opts = {}) {
-  const nuxt = useNuxt();
-  const plugin = normalizePlugin(_plugin);
-  nuxt.options.plugins = nuxt.options.plugins.filter((p) => normalizePlugin(p).src !== plugin.src);
-  nuxt.options.plugins[opts.append ? "push" : "unshift"](plugin);
-  return plugin;
-}
-function addPluginTemplate(plugin, opts = {}) {
-  const normalizedPlugin = typeof plugin === "string" ? { src: plugin } : { ...plugin, src: addTemplate(plugin).dst };
-  return addPlugin(normalizedPlugin, opts);
-}
-
 async function installModule(moduleToInstall, _inlineOptions, _nuxt) {
   const nuxt = useNuxt();
   const { nuxtModule, inlineOptions } = await normalizeModule(moduleToInstall, _inlineOptions);
-  await nuxtModule.call(useModuleContainer(), inlineOptions, nuxt);
+  await nuxtModule(inlineOptions, nuxt);
+  if (typeof moduleToInstall === "string") {
+    nuxt.options.build.transpile.push(moduleToInstall);
+  }
   nuxt.options._installedModules = nuxt.options._installedModules || [];
   nuxt.options._installedModules.push({
     meta: await nuxtModule.getMeta?.(),
@@ -454,14 +425,15 @@ async function installModule(moduleToInstall, _inlineOptions, _nuxt) {
 }
 async function normalizeModule(nuxtModule, inlineOptions) {
   const nuxt = useNuxt();
-  if (nuxtModule?._version || nuxtModule?.version || nuxtModule?.constructor?.version || "") {
-    [nuxtModule, inlineOptions] = [inlineOptions, {}];
-    console.warn(new Error("`installModule` is being called with old signature!"));
-  }
   if (typeof nuxtModule === "string") {
     const _src = resolveModule(resolveAlias(nuxtModule), { paths: nuxt.options.modulesDir });
     const isESM = _src.endsWith(".mjs");
-    nuxtModule = isESM ? await importModule(_src) : requireModule(_src);
+    try {
+      nuxtModule = isESM ? await importModule(_src) : requireModule(_src);
+    } catch (error) {
+      console.error(`Error while requiring module \`${nuxtModule}\`: ${error}`);
+      throw error;
+    }
   }
   if (typeof nuxtModule !== "function") {
     throw new TypeError("Nuxt module should be a function: " + nuxtModule);
@@ -469,223 +441,40 @@ async function normalizeModule(nuxtModule, inlineOptions) {
   return { nuxtModule, inlineOptions };
 }
 
-const MODULE_CONTAINER_KEY = "__module_container__";
-function useModuleContainer(nuxt = useNuxt()) {
-  if (nuxt[MODULE_CONTAINER_KEY]) {
-    return nuxt[MODULE_CONTAINER_KEY];
-  }
-  async function requireModule(moduleOpts) {
-    let src, inlineOptions;
-    if (typeof moduleOpts === "string") {
-      src = moduleOpts;
-    } else if (Array.isArray(moduleOpts)) {
-      [src, inlineOptions] = moduleOpts;
-    } else if (typeof moduleOpts === "object") {
-      if (moduleOpts.src || moduleOpts.handler) {
-        src = moduleOpts.src || moduleOpts.handler;
-        inlineOptions = moduleOpts.options;
-      } else {
-        src = moduleOpts;
-      }
-    } else {
-      src = moduleOpts;
-    }
-    await installModule(src, inlineOptions);
-  }
-  nuxt[MODULE_CONTAINER_KEY] = {
-    nuxt,
-    options: nuxt.options,
-    ready() {
-      return Promise.resolve();
-    },
-    addVendor() {
-    },
-    requireModule,
-    addModule: requireModule,
-    addServerMiddleware,
-    addTemplate(template) {
-      if (typeof template === "string") {
-        template = { src: template };
-      }
-      if (template.write === void 0) {
-        template.write = true;
-      }
-      return addTemplate(template);
-    },
-    addPlugin(pluginTemplate) {
-      return addPluginTemplate(pluginTemplate);
-    },
-    addLayout(tmpl, name) {
-      return addLayout(tmpl, name);
-    },
-    addErrorLayout(dst) {
-      const relativeBuildDir = relative(nuxt.options.rootDir, nuxt.options.buildDir);
-      nuxt.options.ErrorPage = `~/${relativeBuildDir}/${dst}`;
-    },
-    extendBuild(fn) {
-      nuxt.options.build.extend = chainFn(nuxt.options.build.extend, fn);
-      if (!isNuxt2(nuxt)) {
-        console.warn("[kit] [compat] Using `extendBuild` in Nuxt 3 has no effect. Instead call extendWebpackConfig and extendViteConfig.");
-      }
-    },
-    extendRoutes(fn) {
-      if (isNuxt2(nuxt)) {
-        nuxt.options.router.extendRoutes = chainFn(nuxt.options.router.extendRoutes, fn);
-      } else {
-        nuxt.hook("pages:extend", async (pages, ...args) => {
-          const maybeRoutes = await fn(pages, ...args);
-          if (maybeRoutes) {
-            console.warn("[kit] [compat] Using `extendRoutes` in Nuxt 3 needs to directly modify first argument instead of returning updated routes. Skipping extended routes.");
-          }
-        });
-      }
-    }
-  };
-  return nuxt[MODULE_CONTAINER_KEY];
-}
-
-async function compileTemplate(template, ctx) {
-  const data = { ...ctx, options: template.options };
-  if (template.src) {
-    try {
-      const srcContents = await promises.readFile(template.src, "utf-8");
-      return lodashTemplate(srcContents, {})(data);
-    } catch (err) {
-      console.error("Error compiling template: ", template);
-      throw err;
-    }
-  }
-  if (template.getContents) {
-    return template.getContents(data);
-  }
-  throw new Error("Invalid template: " + JSON.stringify(template));
-}
-const serialize = (data) => JSON.stringify(data, null, 2).replace(/"{(.+)}"(?=,?$)/gm, (r) => JSON.parse(r).replace(/^{(.*)}$/, "$1"));
-const importSources = (sources, { lazy = false } = {}) => {
-  if (!Array.isArray(sources)) {
-    sources = [sources];
-  }
-  return sources.map((src) => {
-    if (lazy) {
-      return `const ${genSafeVariableName(src)} = ${genDynamicImport(src, { comment: `webpackChunkName: ${JSON.stringify(src)}` })}`;
-    }
-    return genImport(src, genSafeVariableName(src));
-  }).join("\n");
-};
-const importName = genSafeVariableName;
-const templateUtils = { serialize, importName, importSources };
-
-function defineNuxtModule(definition) {
-  if (typeof definition === "function") {
-    definition = definition(useNuxt());
-    logger.warn("Module definition as function is deprecated and will be removed in the future versions", definition);
-  }
-  if (!definition.meta) {
-    definition.meta = {};
-  }
-  if (!definition.meta.configKey) {
-    definition.meta.name = definition.meta.name || definition.name;
-    definition.meta.configKey = definition.configKey || definition.meta.name;
-  }
-  function getOptions(inlineOptions, nuxt = useNuxt()) {
-    const configKey = definition.meta.configKey || definition.meta.name;
-    const _defaults = definition.defaults instanceof Function ? definition.defaults(nuxt) : definition.defaults;
-    let _options = defu(inlineOptions, nuxt.options[configKey], _defaults);
-    if (definition.schema) {
-      _options = applyDefaults(definition.schema, _options);
-    }
-    return Promise.resolve(_options);
-  }
-  async function normalizedModule(inlineOptions, nuxt) {
-    if (!nuxt) {
-      nuxt = tryUseNuxt() || this.nuxt;
-    }
-    const uniqueKey = definition.meta.name || definition.meta.configKey;
-    if (uniqueKey) {
-      nuxt.options._requiredModules = nuxt.options._requiredModules || {};
-      if (nuxt.options._requiredModules[uniqueKey]) {
-        return;
-      }
-      nuxt.options._requiredModules[uniqueKey] = true;
-    }
-    if (definition.meta.compatibility) {
-      const issues = await checkNuxtCompatibility(definition.meta.compatibility, nuxt);
-      if (issues.length) {
-        logger.warn(`Module \`${definition.meta.name}\` is disabled due to incompatibility issues:
-${issues.toString()}`);
-        return;
-      }
-    }
-    nuxt2Shims(nuxt);
-    const _options = await getOptions(inlineOptions, nuxt);
-    if (definition.hooks) {
-      nuxt.hooks.addHooks(definition.hooks);
-    }
-    await definition.setup?.call(null, _options, nuxt);
-  }
-  normalizedModule.getMeta = () => Promise.resolve(definition.meta);
-  normalizedModule.getOptions = getOptions;
-  return normalizedModule;
-}
-const NUXT2_SHIMS_KEY = "__nuxt2_shims_key__";
-function nuxt2Shims(nuxt) {
-  if (!isNuxt2(nuxt) || nuxt[NUXT2_SHIMS_KEY]) {
-    return;
-  }
-  nuxt[NUXT2_SHIMS_KEY] = true;
-  nuxt.hooks = nuxt;
-  if (!nuxtCtx.tryUse()) {
-    nuxtCtx.set(nuxt);
-    nuxt.hook("close", () => nuxtCtx.unset());
-  }
-  let virtualTemplates;
-  nuxt.hook("builder:prepared", (_builder, buildOptions) => {
-    virtualTemplates = buildOptions.templates.filter((t) => t.getContents);
-    for (const template of virtualTemplates) {
-      buildOptions.templates.splice(buildOptions.templates.indexOf(template), 1);
-    }
-  });
-  nuxt.hook("build:templates", async (templates) => {
-    const context = {
-      nuxt,
-      utils: templateUtils,
-      app: {
-        dir: nuxt.options.srcDir,
-        extensions: nuxt.options.extensions,
-        plugins: nuxt.options.plugins,
-        templates: [
-          ...templates.templatesFiles,
-          ...virtualTemplates
-        ],
-        templateVars: templates.templateVars
-      }
-    };
-    for await (const template of virtualTemplates) {
-      const contents = await compileTemplate({ ...template, src: "" }, context);
-      await promises.mkdir(dirname(template.dst), { recursive: true });
-      await promises.writeFile(template.dst, contents);
-    }
-  });
-}
-
 async function loadNuxtConfig(opts) {
-  const { config: nuxtConfig, configFile, layers, cwd } = await loadConfig({
+  globalThis.defineNuxtConfig = (c) => c;
+  const result = await loadConfig({
     name: "nuxt",
     configFile: "nuxt.config",
     rcFile: ".nuxtrc",
+    extend: { extendKey: ["theme", "extends"] },
     dotenv: true,
     globalRc: true,
     ...opts
   });
+  delete globalThis.defineNuxtConfig;
+  const { configFile, layers = [], cwd } = result;
+  const nuxtConfig = result.config;
   nuxtConfig.rootDir = nuxtConfig.rootDir || cwd;
   nuxtConfig._nuxtConfigFile = configFile;
   nuxtConfig._nuxtConfigFiles = [configFile];
   for (const layer of layers) {
+    layer.config = layer.config || {};
     layer.config.rootDir = layer.config.rootDir ?? layer.cwd;
     layer.config.srcDir = resolve(layer.config.rootDir, layer.config.srcDir);
   }
-  nuxtConfig._layers = layers.filter((layer) => layer.configFile && !layer.configFile.endsWith(".nuxtrc"));
-  return applyDefaults(NuxtConfigSchema, nuxtConfig);
+  const _layers = layers.filter((layer) => layer.configFile && !layer.configFile.endsWith(".nuxtrc"));
+  nuxtConfig._layers = _layers;
+  if (!_layers.length) {
+    _layers.push({
+      cwd,
+      config: {
+        rootDir: cwd,
+        srcDir: cwd
+      }
+    });
+  }
+  return await applyDefaults(NuxtConfigSchema, nuxtConfig);
 }
 
 async function loadNuxt(opts) {
@@ -724,17 +513,25 @@ async function buildNuxt(nuxt) {
   return build(nuxt);
 }
 
-function addAutoImport(imports) {
+function addImports(imports) {
+  assertNuxtCompatibility({ bridge: true });
+  useNuxt().hook("imports:extend", (_imports) => {
+    _imports.push(...Array.isArray(imports) ? imports : [imports]);
+  });
+}
+function addImportsDir(dirs) {
   assertNuxtCompatibility({ bridge: true });
-  useNuxt().hook("autoImports:extend", (autoImports) => {
-    autoImports.push(...Array.isArray(imports) ? imports : [imports]);
+  useNuxt().hook("imports:dirs", (_dirs) => {
+    for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
+      _dirs.push(dir);
+    }
   });
 }
-function addAutoImportDir(_autoImportDirs) {
+function addImportsSources(presets) {
   assertNuxtCompatibility({ bridge: true });
-  useNuxt().hook("autoImports:dirs", (autoImportDirs) => {
-    for (const dir of Array.isArray(_autoImportDirs) ? _autoImportDirs : [_autoImportDirs]) {
-      autoImportDirs.push(dir);
+  useNuxt().hook("imports:sources", (_presets) => {
+    for (const preset of Array.isArray(presets) ? presets : [presets]) {
+      _presets.push(preset);
     }
   });
 }
@@ -760,12 +557,6 @@ function extendWebpackConfig(fn, options = {}) {
         fn(config);
       }
     }
-    if (options.modern !== false) {
-      const config = configs.find((i) => i.name === "modern");
-      if (config) {
-        fn(config);
-      }
-    }
   });
 }
 function extendViteConfig(fn, options = {}) {
@@ -791,13 +582,21 @@ function extendViteConfig(fn, options = {}) {
 function addWebpackPlugin(plugin, options) {
   extendWebpackConfig((config) => {
     config.plugins = config.plugins || [];
-    config.plugins.push(plugin);
+    if (Array.isArray(plugin)) {
+      config.plugins.push(...plugin);
+    } else {
+      config.plugins.push(plugin);
+    }
   }, options);
 }
 function addVitePlugin(plugin, options) {
   extendViteConfig((config) => {
     config.plugins = config.plugins || [];
-    config.plugins.push(plugin);
+    if (Array.isArray(plugin)) {
+      config.plugins.push(...plugin);
+    } else {
+      config.plugins.push(plugin);
+    }
   }, options);
 }
 
@@ -823,10 +622,6 @@ async function addComponent(opts) {
     preload: false,
     mode: "all",
     shortPath: opts.filePath,
-    async: false,
-    level: 0,
-    asyncImport: `${genDynamicImport(opts.filePath)}.then(r => r['${opts.export || "default"}'])`,
-    import: `require(${JSON.stringify(opts.filePath)})['${opts.export || "default"}']`,
     ...opts
   };
   nuxt.hook("components:extend", (components) => {
@@ -841,6 +636,81 @@ async function addComponent(opts) {
   });
 }
 
+function addTemplate(_template) {
+  const nuxt = useNuxt();
+  const template = normalizeTemplate(_template);
+  nuxt.options.build.templates = nuxt.options.build.templates.filter((p) => normalizeTemplate(p).filename !== template.filename);
+  nuxt.options.build.templates.push(template);
+  return template;
+}
+function normalizeTemplate(template) {
+  if (!template) {
+    throw new Error("Invalid template: " + JSON.stringify(template));
+  }
+  if (typeof template === "string") {
+    template = { src: template };
+  } else {
+    template = { ...template };
+  }
+  if (template.src) {
+    if (!existsSync(template.src)) {
+      throw new Error("Template not found: " + template.src);
+    }
+    if (!template.filename) {
+      const srcPath = parse(template.src);
+      template.filename = template.fileName || `${basename(srcPath.dir)}.${srcPath.name}.${hash(template.src)}${srcPath.ext}`;
+    }
+  }
+  if (!template.src && !template.getContents) {
+    throw new Error("Invalid template. Either getContents or src options should be provided: " + JSON.stringify(template));
+  }
+  if (!template.filename) {
+    throw new Error("Invalid template. Either filename should be provided: " + JSON.stringify(template));
+  }
+  if (template.filename.endsWith(".d.ts")) {
+    template.write = true;
+  }
+  if (!template.dst) {
+    const nuxt = useNuxt();
+    template.dst = resolve(nuxt.options.buildDir, template.filename);
+  }
+  return template;
+}
+function updateTemplates(options) {
+  return useNuxt().hooks.callHook("builder:generateApp", options);
+}
+
+function addLayout(template, name) {
+  const nuxt = useNuxt();
+  const { filename, src } = addTemplate(template);
+  const layoutName = kebabCase(name || parse(filename).name).replace(/["']/g, "");
+  if (isNuxt2(nuxt)) {
+    const layout = nuxt.options.layouts[layoutName];
+    if (layout) {
+      return logger.warn(
+        `Not overriding \`${layoutName}\` (provided by \`${layout}\`) with \`${src || filename}\`.`
+      );
+    }
+    nuxt.options.layouts[layoutName] = `./${filename}`;
+    if (name === "error") {
+      this.addErrorLayout(filename);
+    }
+    return;
+  }
+  nuxt.hook("app:templates", (app) => {
+    if (layoutName in app.layouts) {
+      const relativePath = relative(nuxt.options.srcDir, app.layouts[layoutName].file);
+      return logger.warn(
+        `Not overriding \`${layoutName}\` (provided by \`~/${relativePath}\`) with \`${src || filename}\`.`
+      );
+    }
+    app.layouts[layoutName] = {
+      file: join("#build", filename),
+      name: layoutName
+    };
+  });
+}
+
 function extendPages(cb) {
   const nuxt = useNuxt();
   if (isNuxt2(nuxt)) {
@@ -850,4 +720,77 @@ function extendPages(cb) {
   }
 }
 
-export { addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addDevServerHandler, addLayout, addPlugin, addPluginTemplate, addServerHandler, addServerMiddleware, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, useLogger, useModuleContainer, useNuxt };
+function normalizePlugin(plugin) {
+  if (typeof plugin === "string") {
+    plugin = { src: plugin };
+  } else {
+    plugin = { ...plugin };
+  }
+  if (!plugin.src) {
+    throw new Error("Invalid plugin. src option is required: " + JSON.stringify(plugin));
+  }
+  plugin.src = normalize(resolveAlias(plugin.src));
+  if (plugin.ssr) {
+    plugin.mode = "server";
+  }
+  if (!plugin.mode) {
+    const [, mode = "all"] = plugin.src.match(/\.(server|client)(\.\w+)*$/) || [];
+    plugin.mode = mode;
+  }
+  return plugin;
+}
+function addPlugin(_plugin, opts = {}) {
+  const nuxt = useNuxt();
+  const plugin = normalizePlugin(_plugin);
+  nuxt.options.plugins = nuxt.options.plugins.filter((p) => normalizePlugin(p).src !== plugin.src);
+  nuxt.options.plugins[opts.append ? "push" : "unshift"](plugin);
+  return plugin;
+}
+function addPluginTemplate(plugin, opts = {}) {
+  const normalizedPlugin = typeof plugin === "string" ? { src: plugin } : { ...plugin, src: addTemplate(plugin).dst };
+  return addPlugin(normalizedPlugin, opts);
+}
+
+function normalizeHandlerMethod(handler) {
+  const [, method = void 0] = handler.handler.match(/\.(get|head|patch|post|put|delete|connect|options|trace)(\.\w+)*$/) || [];
+  return {
+    method,
+    ...handler,
+    handler: normalize(handler.handler)
+  };
+}
+function addServerHandler(handler) {
+  useNuxt().options.serverHandlers.push(normalizeHandlerMethod(handler));
+}
+function addDevServerHandler(handler) {
+  useNuxt().options.devServerHandlers.push(handler);
+}
+function addServerPlugin(plugin) {
+  const nuxt = useNuxt();
+  nuxt.options.nitro.plugins = nuxt.options.nitro.plugins || [];
+  nuxt.options.nitro.plugins.push(normalize(plugin));
+}
+function addPrerenderRoutes(routes) {
+  const nuxt = useNuxt();
+  if (!Array.isArray(routes)) {
+    routes = [routes];
+  }
+  routes = routes.filter(Boolean);
+  if (!routes.length) {
+    return;
+  }
+  nuxt.hook("prerender:routes", (ctx) => {
+    for (const route of routes) {
+      ctx.routes.add(route);
+    }
+  });
+}
+function useNitro() {
+  const nuxt = useNuxt();
+  if (!nuxt._nitro) {
+    throw new Error("Nitro is not initialized yet. You can call `useNitro()` only after `ready` hook.");
+  }
+  return nuxt._nitro;
+}
+
+export { addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addServerHandler, addServerPlugin, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/kit",
-  "version": "3.0.0-rc.8",
+  "version": "3.0.0",
   "repository": "nuxt/framework",
   "license": "MIT",
   "type": "module",
@@ -9,28 +9,25 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "prepack": "unbuild"
-  },
   "dependencies": {
-    "@nuxt/schema": "3.0.0-rc.8",
-    "c12": "^0.2.9",
+    "@nuxt/schema": "3.0.0",
+    "c12": "^1.0.1",
     "consola": "^2.15.3",
-    "defu": "^6.0.0",
+    "defu": "^6.1.1",
     "globby": "^13.1.2",
     "hash-sum": "^2.0.0",
     "ignore": "^5.2.0",
-    "jiti": "^1.14.0",
-    "knitwork": "^0.1.2",
+    "jiti": "^1.16.0",
+    "knitwork": "^1.0.0",
     "lodash.template": "^4.5.0",
-    "mlly": "^0.5.12",
-    "pathe": "^0.3.4",
-    "pkg-types": "^0.3.3",
-    "scule": "^0.3.2",
-    "semver": "^7.3.7",
-    "unctx": "^2.0.1",
-    "unimport": "^0.6.7",
-    "untyped": "^0.4.5"
+    "mlly": "^1.0.0",
+    "pathe": "^1.0.0",
+    "pkg-types": "^1.0.1",
+    "scule": "^1.0.0",
+    "semver": "^7.3.8",
+    "unctx": "^2.1.0",
+    "unimport": "^1.0.1",
+    "untyped": "^1.0.0"
   },
   "devDependencies": {
     "@types/lodash.template": "^4",
@@ -38,6 +35,7 @@
     "unbuild": "latest"
   },
   "engines": {
-    "node": "^14.16.0 || ^16.11.0 || ^17.0.0 || ^18.0.0"
-  }
-}
+    "node": "^14.16.0 || ^16.10.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+  },
+  "scripts": {}
+}