@nuxt/nitro-server-nightly 5.0.0-29807919.2cbde35e → 5.0.0-29809859.f0ca99e9

package/dist/augments-BYb8I0N-.d.mts

@@ -0,0 +1,365 @@
+import { EventHandler, H3Event } from "nitro/h3";
+import { Import } from "unimport";
+import { Nitro, NitroConfig, NitroDevEventHandler, NitroEventHandler, NitroOptions, NitroRuntimeConfig, NitroRuntimeConfigApp, NormalizedRouteRules, RouteRuleConfig, TracingOptions } from "nitro/types";
+import { Nuxt } from "@nuxt/schema";
+import { LogObject } from "consola";
+import { NuxtIslandContext, NuxtIslandResponse, NuxtRenderChunkContext, NuxtRenderCloseContext, NuxtRenderHTMLContext, NuxtRenderRouteContext } from "#app/types";
+import { HookResult, RuntimeConfig, SharedAppConfig, TSReference } from "nuxt/schema";
+//#region src/auto-imports.d.ts
+/** Options accepted on `nitro.imports`. */
+interface ServerImportsOptions {
+  autoImport?: boolean;
+  dirs?: string[];
+  imports?: Import[];
+  presets?: Array<{
+    from: string;
+    imports: Array<string | {
+      name: string;
+      as?: string;
+    }>;
+    typeFrom?: string;
+  }>;
+  exclude?: Array<string | RegExp>;
+}
+//#endregion
+//#region src/augments.d.ts
+/**
+ * Per-channel toggles for `tracingChannel`. Extends Nitro's own
+ * {@link TracingOptions} with a `nuxt` key for Nuxt-owned channels
+ * (`nuxt.render`, `nuxt.island`, `nuxt.data`, `nuxt.plugin`). Channel names
+ * follow the [untracing](https://github.com/unjs/untracing) naming convention
+ * (`{namespace}.{operation}`).
+ *
+ * @experimental Channel names, payload shapes, and option keys may change.
+ */
+interface NuxtTracingChannelOptions extends TracingOptions {
+  /** Enable Nuxt-owned channels (`nuxt.render`, `nuxt.island`, `nuxt.data`, `nuxt.plugin`). */
+  nuxt?: boolean;
+}
+declare module "nitro/types" {
+  interface NitroRuntimeConfigApp {
+    baseURL: string;
+    buildAssetsDir: string;
+    cdnURL: string;
+    buildId: string;
+  }
+  /**
+   * Server auto-imports, applied by `@nuxt/nitro-server`. Declared here because this is the
+   * channel `addServerImports()` and `addServerImportsDir()` write to through `nitro:config`.
+   */
+  interface NitroConfig {
+    imports?: false | ServerImportsOptions;
+  }
+}
+declare module "h3/rules" {
+  interface RouteRuleConfig {
+    ssr?: boolean;
+    streaming?: boolean;
+    noScripts?: boolean;
+    /** @deprecated Use `noScripts` instead */
+    experimentalNoScripts?: boolean;
+  }
+  interface RouteRules {
+    ssr?: boolean;
+    streaming?: boolean;
+    noScripts?: boolean;
+    /** @deprecated Use `noScripts` instead */
+    experimentalNoScripts?: boolean;
+    appMiddleware?: Record<string, boolean>;
+  }
+}
+declare module "nitro/types" {
+  interface NitroRuntimeConfig extends RuntimeConfig {}
+  interface NitroRuntimeHooks {
+    "dev:ssr-logs": (ctx: {
+      logs: LogObject[];
+      path: string;
+    }) => void | Promise<void>;
+    "render:html": (htmlContext: NuxtRenderHTMLContext, context: {
+      event: H3Event;
+      streaming?: boolean;
+    }) => void | Promise<void>;
+    "render:html:chunk": (chunkContext: NuxtRenderChunkContext, context: {
+      event: H3Event;
+    }) => void | Promise<void>;
+    "render:html:close": (closeContext: NuxtRenderCloseContext, context: {
+      event: H3Event;
+    }) => void | Promise<void>;
+    "render:route": (renderRouteContext: NuxtRenderRouteContext, context: {
+      event: H3Event;
+    }) => void | Promise<void>;
+    "render:island": (islandResponse: NuxtIslandResponse, context: {
+      event: H3Event;
+      islandContext: NuxtIslandContext;
+    }) => void | Promise<void>;
+  }
+}
+type _NitroOnlyRuntimeConfig = Omit<NonNullable<NitroRuntimeConfig["nitro"]>, "envPrefix"> & {
+  envPrefix: string;
+};
+declare module "@nuxt/schema" {
+  interface NitroTypes {
+    instance: Nitro;
+  }
+  interface ServerTypes {
+    event: H3Event;
+    routeRules: NormalizedRouteRules;
+  }
+  interface NuxtHooks {
+    /**
+     * Called when the dev middleware is being registered on the Nitro dev server.
+     * @param handler the Vite or Webpack event handler
+     * @returns Promise
+     */
+    "server:devHandler": (handler: EventHandler, options: {
+      cors: (path: string) => boolean;
+    }) => HookResult;
+    /**
+     * Called before Nitro writes `.nuxt/tsconfig.server.json`, allowing addition of custom references and declarations.
+     * @param options Objects containing `references`, `declarations`
+     * @param options.references Array of TypeScript references to add
+     * @param options.declarations Array of declaration strings to add
+     * @returns Promise
+     */
+    "nitro:prepare:types": (options: {
+      references: TSReference[];
+      declarations: string[];
+    }) => HookResult;
+    /**
+     * Called before initializing Nitro, allowing customization of Nitro's configuration.
+     * @param nitroConfig The nitro config to be extended
+     * @returns Promise
+     */
+    "nitro:config": (nitroConfig: NitroConfig) => HookResult;
+    /**
+     * Called after Nitro is initialized, which allows registering Nitro hooks and interacting directly with Nitro.
+     * @param nitro The created nitro object
+     * @returns Promise
+     */
+    "nitro:init": (nitro: Nitro) => HookResult;
+    /**
+     * Called before building the Nitro instance.
+     * @param nitro The created nitro object
+     * @returns Promise
+     */
+    "nitro:build:before": (nitro: Nitro) => HookResult;
+    /**
+     * Called after copying public assets. Allows modifying public assets before Nitro server is built.
+     * @param nitro The created nitro object
+     * @returns Promise
+     */
+    "nitro:build:public-assets": (nitro: Nitro) => HookResult;
+  }
+  interface ConfigSchema {
+    /**
+     * Configuration for Nitro.
+     *
+     * @see [Nitro configuration docs](https://nitro.build/config)
+     */
+    nitro: NitroConfig;
+    /**
+     * Global route options applied to matching server routes.
+     *
+     * @experimental This is an experimental feature and API may change in the future.
+     *
+     * @see [Nitro route rules documentation](https://nitro.build/config#routerules)
+     */
+    routeRules: NitroConfig["routeRules"];
+    /**
+     * Nitro server handlers.
+     *
+     * Each handler accepts the following options:
+     * - handler: The path to the file defining the handler. - route: The route under which the handler is available. This follows the conventions of [rou3](https://github.com/h3js/rou3). - method: The HTTP method of requests that should be handled. - middleware: Specifies whether it is a middleware handler. - lazy: Specifies whether to use lazy loading to import the handler.
+     *
+     * @see [`server/` directory documentation](https://nuxt.com/docs/4.x/directory-structure/server)
+     *
+     * @note Files from `server/api`, `server/middleware` and `server/routes` will be automatically registered by Nuxt.
+     *
+     * @example
+     * ```js
+     * serverHandlers: [
+     *   { route: '/path/foo/**:name', handler: '#server/foohandler.ts' }
+     * ]
+     * ```
+     */
+    serverHandlers: NitroEventHandler[];
+    /**
+     * Nitro development-only server handlers.
+     *
+     * @see [Nitro server routes documentation](https://nitro.build/guide/routing)
+     */
+    devServerHandlers: NitroDevEventHandler[];
+    /**
+     * Enable [diagnostics-channel](https://nodejs.org/api/diagnostics_channel.html)
+     * tracing for Nuxt-owned subsystems and forward the corresponding Nitro-level
+     * channels (`srvx.request`, `h3.request`, `unstorage.*`).
+     *
+     * @experimental Channel names, payload shapes, and option keys may change.
+     *
+     * @see [Untracing naming registry](https://github.com/unjs/untracing)
+     */
+    tracingChannel: boolean | NuxtTracingChannelOptions;
+  }
+  interface NuxtConfig {
+    nitro?: NitroConfig;
+  }
+  interface RuntimeConfig {
+    app: NitroRuntimeConfigApp;
+    /** Only available on the server. */
+    nitro?: _NitroOnlyRuntimeConfig;
+  }
+  interface NuxtDebugOptions {
+    /** Debug options for Nitro */
+    nitro?: NitroOptions["debug"];
+  }
+  interface NuxtPage {
+    rules?: RouteRuleConfig;
+  }
+}
+declare module "nuxt/schema" {
+  interface NitroTypes {
+    instance: Nitro;
+  }
+  interface ServerTypes {
+    event: H3Event;
+    routeRules: NormalizedRouteRules;
+  }
+  interface NuxtHooks {
+    /**
+     * Called when the dev middleware is being registered on the Nitro dev server.
+     * @param handler the Vite or Webpack event handler
+     * @returns Promise
+     */
+    "server:devHandler": (handler: EventHandler, options: {
+      cors: (path: string) => boolean;
+    }) => HookResult;
+    /**
+     * Called before Nitro writes `.nuxt/tsconfig.server.json`, allowing addition of custom references and declarations.
+     * @param options Objects containing `references`, `declarations`
+     * @param options.references Array of TypeScript references to add
+     * @param options.declarations Array of declaration strings to add
+     * @returns Promise
+     */
+    "nitro:prepare:types": (options: {
+      references: TSReference[];
+      declarations: string[];
+    }) => HookResult;
+    /**
+     * Called before initializing Nitro, allowing customization of Nitro's configuration.
+     * @param nitroConfig The nitro config to be extended
+     * @returns Promise
+     */
+    "nitro:config": (nitroConfig: NitroConfig) => HookResult;
+    /**
+     * Called after Nitro is initialized, which allows registering Nitro hooks and interacting directly with Nitro.
+     * @param nitro The created nitro object
+     * @returns Promise
+     */
+    "nitro:init": (nitro: Nitro) => HookResult;
+    /**
+     * Called before building the Nitro instance.
+     * @param nitro The created nitro object
+     * @returns Promise
+     */
+    "nitro:build:before": (nitro: Nitro) => HookResult;
+    /**
+     * Called after copying public assets. Allows modifying public assets before Nitro server is built.
+     * @param nitro The created nitro object
+     * @returns Promise
+     */
+    "nitro:build:public-assets": (nitro: Nitro) => HookResult;
+  }
+  interface ConfigSchema {
+    /**
+     * Configuration for Nitro.
+     *
+     * @see [Nitro configuration docs](https://nitro.build/config)
+     */
+    nitro: NitroConfig;
+    /**
+     * Global route options applied to matching server routes.
+     *
+     * @experimental This is an experimental feature and API may change in the future.
+     *
+     * @see [Nitro route rules documentation](https://nitro.build/config#routerules)
+     */
+    routeRules: NitroConfig["routeRules"];
+    /**
+     * Nitro server handlers.
+     *
+     * Each handler accepts the following options:
+     * - handler: The path to the file defining the handler. - route: The route under which the handler is available. This follows the conventions of [rou3](https://github.com/h3js/rou3). - method: The HTTP method of requests that should be handled. - middleware: Specifies whether it is a middleware handler. - lazy: Specifies whether to use lazy loading to import the handler.
+     *
+     * @see [`server/` directory documentation](https://nuxt.com/docs/4.x/directory-structure/server)
+     *
+     * @note Files from `server/api`, `server/middleware` and `server/routes` will be automatically registered by Nuxt.
+     *
+     * @example
+     * ```js
+     * serverHandlers: [
+     *   { route: '/path/foo/**:name', handler: '~/server/foohandler.ts' }
+     * ]
+     * ```
+     */
+    serverHandlers: NitroEventHandler[];
+    /**
+     * Nitro development-only server handlers.
+     *
+     * @see [Nitro server routes documentation](https://nitro.build/guide/routing)
+     */
+    devServerHandlers: NitroDevEventHandler[];
+    /**
+     * Enable [diagnostics-channel](https://nodejs.org/api/diagnostics_channel.html)
+     * tracing for Nuxt-owned subsystems and forward the corresponding Nitro-level
+     * channels (`srvx.request`, `h3.request`, `unstorage.*`).
+     *
+     * @experimental Channel names, payload shapes, and option keys may change.
+     *
+     * @see [Untracing naming registry](https://github.com/unjs/untracing)
+     */
+    tracingChannel: boolean | NuxtTracingChannelOptions;
+  }
+  interface NuxtConfig {
+    nitro?: NitroConfig;
+  }
+  interface RuntimeConfig {
+    app: NitroRuntimeConfigApp;
+    /** Only available on the server. */
+    nitro?: _NitroOnlyRuntimeConfig;
+  }
+  interface NuxtDebugOptions {
+    /** Debug options for Nitro */
+    nitro?: NitroOptions["debug"];
+  }
+  interface NuxtPage {
+    rules?: RouteRuleConfig;
+  }
+}
+interface NuxtRequestContext {
+  "appConfig"?: SharedAppConfig;
+  "noSSR"?: boolean;
+  /** @internal */
+  "~internal"?: boolean;
+  /** @internal */
+  "~rendering-error"?: boolean;
+  /**
+   * Dev-only: CSS module URLs the builder has loaded for this request, provided
+   * by a dev integration so the SSR renderer can emit the right stylesheet
+   * links / inline styles. @internal
+   */
+  "~devClientCss"?: string[];
+  /** @internal */
+  "~error-cause"?: unknown;
+}
+declare module "srvx" {
+  interface ServerRequestContext {
+    nuxt?: NuxtRequestContext;
+  }
+}
+declare module "h3" {
+  interface H3EventContext {
+    nuxt?: NuxtRequestContext;
+  }
+}
+//#endregion
+export { NuxtTracingChannelOptions as n, NuxtRequestContext as t };

package/dist/augments.d.mts

@@ -1,337 +1,2 @@
-import { EventHandler, H3Event } from "nitro/h3";
-import { Nitro, NitroConfig, NitroDevEventHandler, NitroEventHandler, NitroOptions, NitroRouteConfig, NitroRouteRules, NitroRuntimeConfig, NitroRuntimeConfigApp, TracingOptions } from "nitro/types";
-import { LogObject } from "consola";
-import { NuxtIslandContext, NuxtIslandResponse, NuxtRenderChunkContext, NuxtRenderCloseContext, NuxtRenderHTMLContext, NuxtRenderRouteContext } from "#app/types";
-import { HookResult, RuntimeConfig, SharedAppConfig, TSReference } from "nuxt/schema";
-//#region src/augments.d.ts
-/**
- * Per-channel toggles for `tracingChannel`. Extends Nitro's own
- * {@link TracingOptions} with a `nuxt` key for Nuxt-owned channels
- * (`nuxt.render`, `nuxt.island`, `nuxt.data`, `nuxt.plugin`). Channel names
- * follow the [untracing](https://github.com/unjs/untracing) naming convention
- * (`{namespace}.{operation}`).
- *
- * @experimental Channel names, payload shapes, and option keys may change.
- */
-interface NuxtTracingChannelOptions extends TracingOptions {
-  /** Enable Nuxt-owned channels (`nuxt.render`, `nuxt.island`, `nuxt.data`, `nuxt.plugin`). */
-  nuxt?: boolean;
-}
-declare module "nitro/types" {
-  interface NitroRuntimeConfigApp {
-    baseURL: string;
-    buildAssetsDir: string;
-    cdnURL: string;
-    buildId: string;
-  }
-  interface NitroRouteRules {
-    ssr?: boolean;
-    streaming?: boolean;
-    noScripts?: boolean;
-    /** @deprecated Use `noScripts` instead */
-    experimentalNoScripts?: boolean;
-    appMiddleware?: Record<string, boolean>;
-  }
-}
-declare module "nitro/types" {
-  interface NitroRuntimeConfig extends RuntimeConfig {}
-  interface NitroRouteConfig {
-    ssr?: boolean;
-    streaming?: boolean;
-    noScripts?: boolean;
-    /** @deprecated Use `noScripts` instead */
-    experimentalNoScripts?: boolean;
-  }
-  interface NitroRuntimeHooks {
-    "dev:ssr-logs": (ctx: {
-      logs: LogObject[];
-      path: string;
-    }) => void | Promise<void>;
-    "render:html": (htmlContext: NuxtRenderHTMLContext, context: {
-      event: H3Event;
-      streaming?: boolean;
-    }) => void | Promise<void>;
-    "render:html:chunk": (chunkContext: NuxtRenderChunkContext, context: {
-      event: H3Event;
-    }) => void | Promise<void>;
-    "render:html:close": (closeContext: NuxtRenderCloseContext, context: {
-      event: H3Event;
-    }) => void | Promise<void>;
-    "render:route": (renderRouteContext: NuxtRenderRouteContext, context: {
-      event: H3Event;
-    }) => void | Promise<void>;
-    "render:island": (islandResponse: NuxtIslandResponse, context: {
-      event: H3Event;
-      islandContext: NuxtIslandContext;
-    }) => void | Promise<void>;
-  }
-}
-type _NitroOnlyRuntimeConfig = Omit<NonNullable<NitroRuntimeConfig["nitro"]>, "envPrefix"> & {
-  envPrefix: string;
-};
-declare module "@nuxt/schema" {
-  interface NitroTypes {
-    instance: Nitro;
-  }
-  interface ServerTypes {
-    event: H3Event;
-    routeRules: NitroRouteRules;
-  }
-  interface NuxtHooks {
-    /**
-     * Called when the dev middleware is being registered on the Nitro dev server.
-     * @param handler the Vite or Webpack event handler
-     * @returns Promise
-     */
-    "server:devHandler": (handler: EventHandler, options: {
-      cors: (path: string) => boolean;
-    }) => HookResult;
-    /**
-     * Called before Nitro writes `.nuxt/tsconfig.server.json`, allowing addition of custom references and declarations.
-     * @param options Objects containing `references`, `declarations`
-     * @param options.references Array of TypeScript references to add
-     * @param options.declarations Array of declaration strings to add
-     * @returns Promise
-     */
-    "nitro:prepare:types": (options: {
-      references: TSReference[];
-      declarations: string[];
-    }) => HookResult;
-    /**
-     * Called before initializing Nitro, allowing customization of Nitro's configuration.
-     * @param nitroConfig The nitro config to be extended
-     * @returns Promise
-     */
-    "nitro:config": (nitroConfig: NitroConfig) => HookResult;
-    /**
-     * Called after Nitro is initialized, which allows registering Nitro hooks and interacting directly with Nitro.
-     * @param nitro The created nitro object
-     * @returns Promise
-     */
-    "nitro:init": (nitro: Nitro) => HookResult;
-    /**
-     * Called before building the Nitro instance.
-     * @param nitro The created nitro object
-     * @returns Promise
-     */
-    "nitro:build:before": (nitro: Nitro) => HookResult;
-    /**
-     * Called after copying public assets. Allows modifying public assets before Nitro server is built.
-     * @param nitro The created nitro object
-     * @returns Promise
-     */
-    "nitro:build:public-assets": (nitro: Nitro) => HookResult;
-  }
-  interface ConfigSchema {
-    /**
-     * Configuration for Nitro.
-     *
-     * @see [Nitro configuration docs](https://nitro.build/config)
-     */
-    nitro: NitroConfig;
-    /**
-     * Global route options applied to matching server routes.
-     *
-     * @experimental This is an experimental feature and API may change in the future.
-     *
-     * @see [Nitro route rules documentation](https://nitro.build/config#routerules)
-     */
-    routeRules: NitroConfig["routeRules"];
-    /**
-     * Nitro server handlers.
-     *
-     * Each handler accepts the following options:
-     * - handler: The path to the file defining the handler. - route: The route under which the handler is available. This follows the conventions of [rou3](https://github.com/h3js/rou3). - method: The HTTP method of requests that should be handled. - middleware: Specifies whether it is a middleware handler. - lazy: Specifies whether to use lazy loading to import the handler.
-     *
-     * @see [`server/` directory documentation](https://nuxt.com/docs/4.x/directory-structure/server)
-     *
-     * @note Files from `server/api`, `server/middleware` and `server/routes` will be automatically registered by Nuxt.
-     *
-     * @example
-     * ```js
-     * serverHandlers: [
-     *   { route: '/path/foo/**:name', handler: '#server/foohandler.ts' }
-     * ]
-     * ```
-     */
-    serverHandlers: NitroEventHandler[];
-    /**
-     * Nitro development-only server handlers.
-     *
-     * @see [Nitro server routes documentation](https://nitro.build/guide/routing)
-     */
-    devServerHandlers: NitroDevEventHandler[];
-    /**
-     * Enable [diagnostics-channel](https://nodejs.org/api/diagnostics_channel.html)
-     * tracing for Nuxt-owned subsystems and forward the corresponding Nitro-level
-     * channels (`srvx.request`, `h3.request`, `unstorage.*`).
-     *
-     * @experimental Channel names, payload shapes, and option keys may change.
-     *
-     * @see [Untracing naming registry](https://github.com/unjs/untracing)
-     */
-    tracingChannel: boolean | NuxtTracingChannelOptions;
-  }
-  interface NuxtConfig {
-    nitro?: NitroConfig;
-  }
-  interface RuntimeConfig {
-    app: NitroRuntimeConfigApp;
-    /** Only available on the server. */
-    nitro?: _NitroOnlyRuntimeConfig;
-  }
-  interface NuxtDebugOptions {
-    /** Debug options for Nitro */
-    nitro?: NitroOptions["debug"];
-  }
-  interface NuxtPage {
-    rules?: NitroRouteConfig;
-  }
-}
-declare module "nuxt/schema" {
-  interface NitroTypes {
-    instance: Nitro;
-  }
-  interface ServerTypes {
-    event: H3Event;
-    routeRules: NitroRouteRules;
-  }
-  interface NuxtHooks {
-    /**
-     * Called when the dev middleware is being registered on the Nitro dev server.
-     * @param handler the Vite or Webpack event handler
-     * @returns Promise
-     */
-    "server:devHandler": (handler: EventHandler, options: {
-      cors: (path: string) => boolean;
-    }) => HookResult;
-    /**
-     * Called before Nitro writes `.nuxt/tsconfig.server.json`, allowing addition of custom references and declarations.
-     * @param options Objects containing `references`, `declarations`
-     * @param options.references Array of TypeScript references to add
-     * @param options.declarations Array of declaration strings to add
-     * @returns Promise
-     */
-    "nitro:prepare:types": (options: {
-      references: TSReference[];
-      declarations: string[];
-    }) => HookResult;
-    /**
-     * Called before initializing Nitro, allowing customization of Nitro's configuration.
-     * @param nitroConfig The nitro config to be extended
-     * @returns Promise
-     */
-    "nitro:config": (nitroConfig: NitroConfig) => HookResult;
-    /**
-     * Called after Nitro is initialized, which allows registering Nitro hooks and interacting directly with Nitro.
-     * @param nitro The created nitro object
-     * @returns Promise
-     */
-    "nitro:init": (nitro: Nitro) => HookResult;
-    /**
-     * Called before building the Nitro instance.
-     * @param nitro The created nitro object
-     * @returns Promise
-     */
-    "nitro:build:before": (nitro: Nitro) => HookResult;
-    /**
-     * Called after copying public assets. Allows modifying public assets before Nitro server is built.
-     * @param nitro The created nitro object
-     * @returns Promise
-     */
-    "nitro:build:public-assets": (nitro: Nitro) => HookResult;
-  }
-  interface ConfigSchema {
-    /**
-     * Configuration for Nitro.
-     *
-     * @see [Nitro configuration docs](https://nitro.build/config)
-     */
-    nitro: NitroConfig;
-    /**
-     * Global route options applied to matching server routes.
-     *
-     * @experimental This is an experimental feature and API may change in the future.
-     *
-     * @see [Nitro route rules documentation](https://nitro.build/config#routerules)
-     */
-    routeRules: NitroConfig["routeRules"];
-    /**
-     * Nitro server handlers.
-     *
-     * Each handler accepts the following options:
-     * - handler: The path to the file defining the handler. - route: The route under which the handler is available. This follows the conventions of [rou3](https://github.com/h3js/rou3). - method: The HTTP method of requests that should be handled. - middleware: Specifies whether it is a middleware handler. - lazy: Specifies whether to use lazy loading to import the handler.
-     *
-     * @see [`server/` directory documentation](https://nuxt.com/docs/4.x/directory-structure/server)
-     *
-     * @note Files from `server/api`, `server/middleware` and `server/routes` will be automatically registered by Nuxt.
-     *
-     * @example
-     * ```js
-     * serverHandlers: [
-     *   { route: '/path/foo/**:name', handler: '~/server/foohandler.ts' }
-     * ]
-     * ```
-     */
-    serverHandlers: NitroEventHandler[];
-    /**
-     * Nitro development-only server handlers.
-     *
-     * @see [Nitro server routes documentation](https://nitro.build/guide/routing)
-     */
-    devServerHandlers: NitroDevEventHandler[];
-    /**
-     * Enable [diagnostics-channel](https://nodejs.org/api/diagnostics_channel.html)
-     * tracing for Nuxt-owned subsystems and forward the corresponding Nitro-level
-     * channels (`srvx.request`, `h3.request`, `unstorage.*`).
-     *
-     * @experimental Channel names, payload shapes, and option keys may change.
-     *
-     * @see [Untracing naming registry](https://github.com/unjs/untracing)
-     */
-    tracingChannel: boolean | NuxtTracingChannelOptions;
-  }
-  interface NuxtConfig {
-    nitro?: NitroConfig;
-  }
-  interface RuntimeConfig {
-    app: NitroRuntimeConfigApp;
-    /** Only available on the server. */
-    nitro?: _NitroOnlyRuntimeConfig;
-  }
-  interface NuxtDebugOptions {
-    /** Debug options for Nitro */
-    nitro?: NitroOptions["debug"];
-  }
-  interface NuxtPage {
-    rules?: NitroRouteConfig;
-  }
-}
-interface NuxtRequestContext {
-  "appConfig"?: SharedAppConfig;
-  "noSSR"?: boolean;
-  /** @internal */
-  "~internal"?: boolean;
-  /** @internal */
-  "~rendering-error"?: boolean;
-  /**
-   * Dev-only: CSS module URLs the builder has loaded for this request, provided
-   * by a dev integration so the SSR renderer can emit the right stylesheet
-   * links / inline styles. @internal
-   */
-  "~devClientCss"?: string[];
-  /** @internal */
-  "~error-cause"?: unknown;
-}
-declare module "srvx" {
-  interface ServerRequestContext {
-    nuxt?: NuxtRequestContext;
-  }
-}
-declare module "h3" {
-  interface H3EventContext {
-    nuxt?: NuxtRequestContext;
-  }
-}
-//#endregion
+import { n as NuxtTracingChannelOptions, t as NuxtRequestContext } from "./augments-BYb8I0N-.mjs";
 export { NuxtRequestContext, NuxtTracingChannelOptions };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { NuxtTracingChannelOptions } from "./augments.mjs";
+import { n as NuxtTracingChannelOptions } from "./augments-BYb8I0N-.mjs";
 import { Nitro } from "nitro/types";
 import { Nuxt } from "@nuxt/schema";
 //#region src/index.d.ts

package/dist/index.mjs

@@ -7,8 +7,8 @@ import { randomBytes, randomUUID } from "node:crypto";
 import { dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
 import { getQuery, joinURL, withTrailingSlash, withoutTrailingSlash } from "ufo";
 import nuxtPkg from "nuxt/package.json" with { type: "json" };
-import { build, copyPublicAssets, createDevServer, createNitro, prepare, prerender, writeTypes } from "nitro/builder";
-import { addPlugin, addTemplate, addVitePlugin, createIsIgnored, directoryToURL, ensureDependencyInstalled, findPath, getAddDependencyCommand, getDirectory, getLayerDirectories, logger, resolveAlias, resolveIgnorePatterns, resolveNuxtModule } from "@nuxt/kit";
+import { build, copyPublicAssets, createDevServer, createNitro, prepare, prerender } from "nitro/builder";
+import { addPlugin, addTemplate, addVitePlugin, createIsIgnored, directoryToURL, ensureDependencyInstalled, findPath, getAddDependencyCommand, getLayerDirectories, logger, resolveAlias, resolveIgnorePatterns } from "@nuxt/kit";
 import { bundlerDiagnostics, resolveModuleExportNames, setServerBuild } from "@nuxt/kit/internal";
 import escapeRE from "escape-string-regexp";
 import { defu } from "defu";
@@ -24,8 +24,10 @@ import MagicString from "magic-string";
 import remapping from "@ampproject/remapping";
 import { addRoute, createRouter, routeNodeKeys } from "rou3";
 import { compileRouterToString } from "rou3/compiler";
+import { createUnimport, scanDirExports, toExports } from "unimport";
+import { createUnplugin } from "unplugin";
 //#region package.json
-var version = "5.0.0-29807919.2cbde35e";
+var version = "5.0.0-29809859.f0ca99e9";
 //#endregion
 //#region src/utils.ts
 function toArray(value) {
@@ -167,10 +169,6 @@ function setupNitroViteEnvironment(nuxt, nitro$1) {
 			"}"
 		].join("\n");
 	}
-	if (nuxt.options.dev) {
-		nuxt.options.vite.server ||= {};
-		nuxt.options.vite.server.perEnvironmentStartEndDuringDev = true;
-	}
 	nuxt.options.vite.plugins ||= [];
 	nuxt.options.vite.plugins.push(nitro({
 		_nitro: nitro$1,
@@ -688,14 +686,25 @@ declare module 'nitro/types' {
     cdnURL: string
   }
   interface NitroRuntimeConfig extends RuntimeConfig {}
-  interface NitroRouteConfig {
+  interface NitroRuntimeHooks {
+    'dev:ssr-logs': (ctx: { logs: LogObject[], path: string }) => void | Promise<void>
+    'render:html': (htmlContext: NuxtRenderHTMLContext, context: { event: H3Event, streaming?: boolean }) => void | Promise<void>
+    'render:html:chunk': (chunkContext: NuxtRenderChunkContext, context: { event: H3Event }) => void | Promise<void>
+    'render:html:close': (closeContext: NuxtRenderCloseContext, context: { event: H3Event }) => void | Promise<void>
+    'render:route': (renderRouteContext: NuxtRenderRouteContext, context: { event: H3Event }) => void | Promise<void>
+    'render:island': (islandResponse: NuxtIslandResponse, context: { event: H3Event, islandContext: NuxtIslandContext }) => void | Promise<void>
+  }
+}
+
+declare module 'h3/rules' {
+  interface RouteRuleConfig {
     ssr?: boolean
     streaming?: boolean
     noScripts?: boolean
     /** @deprecated Use \`noScripts\` instead */
     experimentalNoScripts?: boolean
   }
-  interface NitroRouteRules {
+  interface RouteRules {
     ssr?: boolean
     streaming?: boolean
     noScripts?: boolean
@@ -704,14 +713,6 @@ declare module 'nitro/types' {
     appMiddleware?: Record<string, boolean>
     appLayout?: string | false
   }
-  interface NitroRuntimeHooks {
-    'dev:ssr-logs': (ctx: { logs: LogObject[], path: string }) => void | Promise<void>
-    'render:html': (htmlContext: NuxtRenderHTMLContext, context: { event: H3Event, streaming?: boolean }) => void | Promise<void>
-    'render:html:chunk': (chunkContext: NuxtRenderChunkContext, context: { event: H3Event }) => void | Promise<void>
-    'render:html:close': (closeContext: NuxtRenderCloseContext, context: { event: H3Event }) => void | Promise<void>
-    'render:route': (renderRouteContext: NuxtRenderRouteContext, context: { event: H3Event }) => void | Promise<void>
-    'render:island': (islandResponse: NuxtIslandResponse, context: { event: H3Event, islandContext: NuxtIslandContext }) => void | Promise<void>
-  }
 }
 `;
 	}
@@ -782,52 +783,188 @@ async function getH3ImportsPreset() {
 		imports: (await resolveModuleExportNames("nitro/h3", { url: import.meta.url })).filter((n) => !/^[A-Z]/.test(n) && n !== "use")
 	};
 }
-const PACKAGE_SUBPATH_RE = /^(?:@[^/]+\/)?[^@./][^/]*\/.+$/;
-/**
-* Nitro derives the type import path of an auto-import from the resolved file's package `exports`
-* subpath, re-attached to the package directory. For a package whose `exports` map does not mirror
-* its file layout that names a file which does not exist, and under `skipLibCheck` TypeScript
-* silently widens every import from it to `any`.
-*
-* An absolute `typeFrom` bypasses that resolution entirely, so point it at a generated module that
-* re-exports the resolved file by relative path, extension intact, so the package's own declaration
-* file is found.
-*
-* TODO: remove once the next Nitro beta includes https://github.com/nitrojs/nitro/pull/4565
-*/
-function withImportTypeShims(presets, shimDir) {
-	const shimmed = [];
-	const shims = [];
-	for (const preset of presets) {
-		const resolved = PACKAGE_SUBPATH_RE.test(preset.from) && resolveModulePath(preset.from, {
-			try: true,
-			from: import.meta.url
+//#endregion
+//#region src/auto-imports.ts
+/** Creates and applies the auto-imports available to the modules the server builder bundles. */
+function createServerAutoImports(nuxt, options, typesDir) {
+	const enabled = options.autoImport !== false;
+	const importsModulePath = join(typesDir, "types/server-imports");
+	const importsModuleDir = dirname(importsModulePath);
+	const ctx = createUnimport({
+		parser: "oxc",
+		injectAtEnd: true,
+		presets: options.presets ?? [],
+		imports: options.imports ?? [],
+		addons: { addons: [] }
+	});
+	const isIgnored = createIsIgnored(nuxt);
+	const scanDirs = options.dirs ?? [];
+	let initialised;
+	function init() {
+		initialised ??= (async () => {
+			await ctx.init();
+			await scan();
+		})();
+		return initialised;
+	}
+	async function scan() {
+		if (scanDirs.length === 0) return;
+		await ctx.modifyDynamicImports(async (imports) => {
+			const scanned = await scanDirExports(scanDirs, { fileFilter: (file) => !isIgnored(file) });
+			imports.push(...scanned);
+			return imports;
 		});
-		if (!resolved) {
-			shimmed.push(preset);
-			continue;
+	}
+	/**
+	* Resolve the module an import's types are read from to a specifier the generated declaration
+	* file can name.
+	*
+	* A bare specifier is left as written so it resolves through the package's `exports` map: an
+	* extensionless relative path cannot reach a subpath shipping only `foo.d.mts`, and under
+	* `skipLibCheck` that silently widens every symbol from it to `any`.
+	*/
+	const resolvedTypePaths = /* @__PURE__ */ new Map();
+	function resolveTypePaths(imports) {
+		for (const i of imports) {
+			const from = i.typeFrom || i.from;
+			if (resolvedTypePaths.has(from)) continue;
+			resolvedTypePaths.set(from, isAbsolute(from) ? relativeWithDot$1(importsModuleDir, from).replace(/\.[cm]?[jt]sx?$/, "") : from);
 		}
-		const shim = join(shimDir, preset.from.replace(/\W/g, "_") + ".ts");
-		const specifier = relative(shimDir, normalize(resolved));
-		shims.push([shim, `export * from '${specifier.startsWith(".") ? specifier : "./" + specifier}'\n`]);
-		shimmed.push({
-			...preset,
-			typeFrom: shim
-		});
 	}
 	return {
-		presets: shimmed,
-		async writeShims() {
-			if (shims.length === 0) return;
-			await mkdir(shimDir, { recursive: true });
-			await Promise.all(shims.map(([path, contents]) => writeFile(path, contents, "utf-8")));
+		enabled,
+		importsModulePath,
+		async injectImports(code, id, injectOptions) {
+			if (!enabled) return;
+			await init();
+			return ctx.injectImports(code, id, {
+				autoImport: true,
+				id,
+				...injectOptions
+			});
+		},
+		async getImports() {
+			if (!enabled) return [];
+			await init();
+			return ctx.getImports();
+		},
+		async refresh() {
+			if (!enabled) return;
+			await init();
+			resolvedTypePaths.clear();
+			await ctx.modifyDynamicImports((imports) => {
+				imports.length = 0;
+				return imports;
+			});
+			await scan();
+		},
+		async writeTypes() {
+			await mkdir(join(typesDir, "types"), { recursive: true });
+			if (!enabled) {
+				await writeFile(importsModulePath + ".d.ts", "export {}\n", "utf8");
+				await writeFile(importsModulePath + ".mjs", "export {}\n", "utf8");
+				return;
+			}
+			await init();
+			const imports = await ctx.getImports();
+			resolveTypePaths(imports);
+			const declarations = await ctx.generateTypeDeclarations({
+				exportHelper: false,
+				resolvePath: (i) => resolvedTypePaths.get(i.typeFrom || i.from) ?? i.from
+			});
+			const reExports = toExports(imports, importsModuleDir, true);
+			await Promise.all([writeFile(importsModulePath + ".d.ts", [
+				declarations.trim(),
+				reExports.trim() || "export {}",
+				""
+			].join("\n"), "utf8"), writeFile(importsModulePath + ".mjs", (toExports(imports, importsModuleDir).trim() || "export {}") + "\n", "utf8")]);
 		}
 	};
 }
+/** Resolve the directories scanned for server auto-imports across all layers. */
+function resolveServerImportDirs(nuxt) {
+	const dirs = /* @__PURE__ */ new Set();
+	if (nuxt.options.imports.scan === false) return [];
+	for (const layer of nuxt.options._layers) {
+		if (layer.config?.imports?.scan === false) continue;
+		const shared = layer.config.dir?.shared ?? "shared";
+		dirs.add(join(layer.config.rootDir, shared, "utils"));
+		dirs.add(join(layer.config.rootDir, shared, "types"));
+		dirs.add(join(layer.config.serverDir ?? join(layer.config.rootDir, "server"), "utils"));
+		dirs.add(join(layer.config.serverDir ?? join(layer.config.rootDir, "server"), "types"));
+	}
+	return [...dirs];
+}
+const RELATIVE_RE$1 = /^\.{1,2}\//;
+function relativeWithDot$1(from, to) {
+	const rel = relative(from, to);
+	return RELATIVE_RE$1.test(rel) ? rel : "./" + rel;
+}
+//#endregion
+//#region src/route-rules.ts
+/**
+* Rewrites `redirect.statusCode` to `redirect.status`, warning once per route.
+*
+* The nitro v2 spelling is silently ignored by the version Nuxt now builds on, which would turn
+* a configured redirect status into a default without any indication.
+*/
+function normalizeLegacyRouteRules(routeRules) {
+	for (const route in routeRules) {
+		const redirect = routeRules[route]?.redirect;
+		if (!redirect || typeof redirect !== "object" || !("statusCode" in redirect)) continue;
+		const { statusCode, ...rest } = redirect;
+		routeRules[route].redirect = {
+			...rest,
+			status: rest.status ?? statusCode
+		};
+		bundlerDiagnostics.NUXT_B7026({ route });
+	}
+}
+//#endregion
+//#region src/auto-imports-plugin.ts
+const EXCLUDE_RE = [/[\\/]node_modules[\\/]/, /[\\/]\.git[\\/]/];
+const INCLUDE_RE = /\.[cm]?[jt]sx?$/;
+/**
+* Injects the server auto-imports.
+*
+* Registered on both the Rollup config and the `nitro` Vite environment, as either may build the
+* server bundle depending on `experimental.nitroViteEnvironment`.
+*/
+const ServerAutoImportsPlugin = createUnplugin(({ autoImports, sourcemap }) => {
+	return {
+		name: "nuxt:server-auto-imports",
+		enforce: "post",
+		transformInclude(id) {
+			const path = normalize(id);
+			return INCLUDE_RE.test(path.split("?")[0]) && !EXCLUDE_RE.some((re) => re.test(path));
+		},
+		async transform(code, id) {
+			const result = await autoImports.injectImports(code, id);
+			if (!result?.s.hasChanged()) return;
+			return {
+				code: result.s.toString(),
+				map: sourcemap ? result.s.generateMap({ hires: true }) : void 0
+			};
+		}
+	};
+});
 //#endregion
 //#region src/index.ts
 /** Subpath the request-shape extractors are imported from in generated declarations. */
 const REQUEST_TYPES_MODULE = "@nuxt/nitro-server/request-types";
+const excludedServerAlias = [
+	/^@vue\/.*$/,
+	"vue",
+	/vue-router/,
+	"vite/client",
+	/^#imports/,
+	"vue-demi",
+	/^#app/,
+	"~",
+	"@",
+	"~~",
+	"@@"
+];
 const logLevelMapReverse = {
 	silent: 0,
 	info: 3,
@@ -843,21 +980,9 @@ async function bundle(nuxt) {
 		dir: dirs.public,
 		maxAge: 0
 	});
-	const rootDirWithSlash = withTrailingSlash(nuxt.options.rootDir);
-	const moduleEntryPaths = [];
-	for (const m of nuxt.options._installedModules) {
-		const path = m.meta?.rawPath || m.entryPath;
-		if (path) moduleEntryPaths.push(getDirectory(path));
-	}
-	const modules = await resolveNuxtModule(rootDirWithSlash, moduleEntryPaths);
 	addTemplate(nitroSchemaTemplate);
 	const importDirs = /* @__PURE__ */ new Set();
-	if (nuxt.options.nitro.imports !== false && nuxt.options.imports.scan !== false) for (const layer of nuxt.options._layers) {
-		if (layer.config?.imports?.scan === false) continue;
-		importDirs.add(resolve(layer.config.rootDir, layer.config.dir?.shared ?? "shared", "utils"));
-		importDirs.add(resolve(layer.config.rootDir, layer.config.dir?.shared ?? "shared", "types"));
-		importDirs.add(resolve(layer.config.serverDir ?? resolve(layer.config.rootDir, "server"), "types"));
-	}
+	if (nuxt.options.nitro.imports !== false) for (const dir of resolveServerImportDirs(nuxt)) importDirs.add(dir);
 	nuxt.options.nitro.plugins ||= [];
 	nuxt.options.nitro.plugins = nuxt.options.nitro.plugins.map((plugin) => plugin ? resolveAlias(plugin, nuxt.options.alias) : plugin);
 	for (const asset of [...nuxt.options.nitro.publicAssets || [], ...nuxt.options.nitro.serverAssets || []]) if (asset?.dir) asset.dir = resolveAlias(asset.dir, nuxt.options.alias);
@@ -897,15 +1022,8 @@ async function bundle(nuxt) {
 	}
 	const mockProxy = resolveModulePath("mocked-exports/proxy", { from: import.meta.url });
 	const typesDir = nuxt.options.typesDir || nuxt.options.buildDir;
-	const autoImports = nuxt.options.experimental.nitroAutoImports ? withImportTypeShims([...v2ImportsPreset, await getH3ImportsPreset()], join(typesDir, "types/nitro-import-shims")) : {
-		presets: [],
-		writeShims: () => Promise.resolve()
-	};
-	const globalCompilerOptions = { ...nuxt.options.typescript?.tsConfig?.compilerOptions };
-	delete globalCompilerOptions.types;
-	delete globalCompilerOptions.paths;
-	delete globalCompilerOptions.noEmit;
-	const nitroConfig = defu(nuxt.options.nitro, { typescript: { tsConfig: { compilerOptions: globalCompilerOptions } } }, {
+	const autoImportPresets = nuxt.options.experimental.nitroAutoImports ? [...v2ImportsPreset, await getH3ImportsPreset()] : [];
+	const nitroConfig = defu(nuxt.options.nitro, {
 		debug: nuxt.options.debug ? nuxt.options.debug.nitro : false,
 		rootDir: nuxt.options.rootDir,
 		workspaceDir: nuxt.options.workspaceDir,
@@ -923,7 +1041,7 @@ async function bundle(nuxt) {
 		imports: {
 			autoImport: nuxt.options.imports.autoImport,
 			dirs: [...importDirs],
-			presets: autoImports.presets,
+			presets: autoImportPresets,
 			imports: [
 				{
 					as: "__buildAssetsURL",
@@ -997,35 +1115,6 @@ async function bundle(nuxt) {
 			"/__nuxt_error": { cache: false }
 		},
 		rolldownConfig: { tsconfig: false },
-		typescript: {
-			generateTsConfig: true,
-			tsconfigPath: join(typesDir, "tsconfig.server.json"),
-			generatedTypesDir: join(typesDir, "types/nitro"),
-			tsConfig: {
-				compilerOptions: {
-					lib: [
-						"esnext",
-						"webworker",
-						"dom.iterable"
-					],
-					skipLibCheck: true,
-					noEmit: true,
-					moduleResolution: "bundler",
-					noUncheckedIndexedAccess: true,
-					allowArbitraryExtensions: true
-				},
-				include: [
-					join(typesDir, "types/nitro-nuxt.d.ts"),
-					...modules.flatMap((m) => {
-						const moduleDir = relativeWithDot(typesDir, m);
-						return [join(moduleDir, "runtime/server"), join(moduleDir, "dist/runtime/server")];
-					}),
-					...layerDirs.map((dirs) => relativeWithDot(typesDir, join(dirs.server, "**/*"))),
-					...layerDirs.map((dirs) => relativeWithDot(typesDir, join(dirs.shared, "**/*.d.ts")))
-				],
-				exclude: [...nuxt.options.modulesDir.map((m) => relativeWithDot(typesDir, m)), relativeWithDot(typesDir, resolve(nuxt.options.rootDir, "dist"))]
-			}
-		},
 		publicAssets: [nuxt.options.dev ? {
 			dir: resolve(nuxt.options.buildDir, "dist/client"),
 			maxAge: 0
@@ -1279,67 +1368,36 @@ async function bundle(nuxt) {
 	};
 	const cacheDriverPath = join(distDir, "runtime/utils/cache-driver.mjs");
 	const cacheDriverOption = isWindows ? pathToFileURL(cacheDriverPath).href : cacheDriverPath;
-	nuxt.options.typescript.hoist.push("nitro", "nitro/app", "nitro/builder", "nitro/cache", "nitro/config", "nitro/context", "nitro/database", "nitro/h3", "nitro/meta", "nitro/runtime-config", "nitro/storage", "nitro/task", "nitro/types", "nitropack/types", "nitropack/runtime", "nitropack", "srvx", "defu", "h3", "consola", "ofetch", "crossws");
+	nuxt.options.typescript.hoist.push("nitro", "nitro/app", "nitro/builder", "nitro/cache", "nitro/config", "nitro/context", "nitro/database", "nitro/h3", "nitro/meta", "nitro/runtime-config", "nitro/storage", "nitro/task", "nitro/types", "nitropack/types", "nitropack/runtime", "nitropack", "srvx", "defu", "h3", "h3/rules", "consola", "ofetch", "crossws");
 	await nuxt.callHook("nitro:config", nitroConfig);
+	normalizeLegacyRouteRules(nitroConfig.routeRules);
+	const autoImports = createServerAutoImports(nuxt, nitroConfig.imports || { autoImport: false }, typesDir);
+	nitroConfig.alias ||= {};
+	nitroConfig.alias["#imports/server"] = autoImports.importsModulePath;
+	nitroConfig.alias["#imports"] = autoImports.importsModulePath;
+	if (autoImports.enabled) {
+		const autoImportsPluginOptions = {
+			autoImports,
+			sourcemap: !!nuxt.options.sourcemap.server
+		};
+		nitroConfig.rollupConfig.plugins.push(ServerAutoImportsPlugin.rollup(autoImportsPluginOptions));
+		if (nuxt.options.experimental.nitroViteEnvironment) {
+			nuxt.options.vite.plugins ||= [];
+			for (const plugin of [ServerAutoImportsPlugin.vite(autoImportsPluginOptions)].flat()) nuxt.options.vite.plugins.push(Object.assign(plugin, { applyToEnvironment: (env) => env.name === "nitro" }));
+		}
+		const scannedDirs = nitroConfig.imports.dirs ?? [];
+		nuxt.hook("builder:watch", async (event, relativePath) => {
+			if (event !== "add" && event !== "unlink") return;
+			const path = resolve(nuxt.options.srcDir, relativePath);
+			if (!scannedDirs.some((dir) => path === dir || path.startsWith(dir + "/"))) return;
+			await autoImports.refresh();
+			await autoImports.writeTypes();
+		});
+	}
 	if (nitroConfig.static && nuxt.options.dev) {
 		nitroConfig.routeRules ||= {};
 		nitroConfig.routeRules["/**"] = defu(nitroConfig.routeRules["/**"], { prerender: true });
 	}
-	const excludedAlias = [
-		/^@vue\/.*$/,
-		"vue",
-		/vue-router/,
-		"vite/client",
-		"#imports",
-		"vue-demi",
-		/^#app/,
-		"~",
-		"@",
-		"~~",
-		"@@"
-	];
-	const isV5OrHigher = nuxt.options.future.compatibilityVersion >= 5;
-	const baseUrl = isV5OrHigher ? void 0 : nitroConfig.typescript.tsConfig.compilerOptions?.baseUrl;
-	const basePath = baseUrl ? resolve(typesDir, baseUrl) : typesDir;
-	const aliases = nitroConfig.alias;
-	const importPaths = nuxt.options.modulesDir.map((d) => pathToFileURL(withTrailingSlash(d)));
-	const tsConfig = nitroConfig.typescript.tsConfig;
-	tsConfig.compilerOptions ||= {};
-	if (isV5OrHigher) Reflect.deleteProperty(tsConfig.compilerOptions, "baseUrl");
-	tsConfig.compilerOptions.paths ||= {};
-	for (const _alias in aliases) {
-		const alias = _alias;
-		if (excludedAlias.some((pattern) => typeof pattern === "string" ? alias === pattern : pattern.test(alias))) continue;
-		if (alias in tsConfig.compilerOptions.paths) continue;
-		let absolutePath = resolve(basePath, aliases[alias]);
-		let stats = await promises.stat(absolutePath).catch(() => null);
-		if (!stats) {
-			const resolvedModule = resolveModulePath(aliases[alias], {
-				try: true,
-				from: importPaths,
-				extensions: [
-					...nuxt.options.extensions,
-					".d.ts",
-					".d.mts",
-					".d.cts"
-				]
-			});
-			if (resolvedModule) {
-				absolutePath = resolvedModule;
-				stats = await promises.stat(resolvedModule).catch(() => null);
-			}
-		}
-		const isDirectory = aliases[alias].endsWith("/") || stats?.isDirectory();
-		tsConfig.compilerOptions.paths[alias] = [absolutePath];
-		if (isDirectory) tsConfig.compilerOptions.paths[`${alias}/*`] = [`${absolutePath}/*`];
-	}
-	const appDir = nuxt.options.alias["#app"];
-	if (appDir) {
-		tsConfig.compilerOptions.paths["#app/island-hash"] ||= [resolve(appDir, "island-hash")];
-		tsConfig.compilerOptions.paths["#app/island-props"] ||= [resolve(appDir, "island-props")];
-		tsConfig.compilerOptions.paths["#app/internal/*"] ||= [resolve(appDir, "internal/*")];
-		tsConfig.compilerOptions.paths["#app/types"] ||= [resolve(appDir, "types")];
-	}
 	if (nuxt.options.experimental.nitroViteEnvironment) nitroConfig.renderer = void 0;
 	nuxt._perf?.startPhase("nitro:createNitro");
 	const nitro = await createNitro(nitroConfig, {
@@ -1380,6 +1438,7 @@ async function bundle(nuxt) {
 			dev: true
 		},
 		buildsSeparately: !nuxt.options.experimental.nitroViteEnvironment,
+		imports: () => autoImports.getImports(),
 		preview: { command: () => nitro.options.commands.preview }
 	}, nuxt);
 	await nuxt.callHook("nitro:init", nitro);
@@ -1522,21 +1581,58 @@ async function bundle(nuxt) {
 			});
 		}
 	});
-	if (nuxt.options.dev) nitro.hooks.hook("types:extend", async () => {
-		await nuxt.callHook("builder:generateApp", { filter: (template) => template.filename === "server-routes.d.ts" });
-	});
-	nitro.hooks.hook("types:extend", (types) => {
-		types.tsConfig ||= {};
-		const rootDirGlob = relativeWithDot(typesDir, join(nuxt.options.rootDir, "**/*"));
-		types.tsConfig.include = types.tsConfig.include?.filter((i) => i !== rootDirGlob);
-	});
 	nuxt.hook("prepare:types", async (opts) => {
-		await autoImports.writeShims();
-		await writeTypes(nitro);
+		await autoImports.writeTypes();
+		opts.serverTsConfig.compilerOptions ||= {};
+		opts.serverTsConfig.compilerOptions.paths ||= {};
+		opts.serverTsConfig.compilerOptions.paths["#imports/server"] = [relativeWithDot(typesDir, autoImports.importsModulePath)];
+		opts.tsConfig.compilerOptions ||= {};
+		opts.tsConfig.compilerOptions.paths ||= {};
+		opts.tsConfig.compilerOptions.paths["#imports/server"] = [relativeWithDot(typesDir, autoImports.importsModulePath)];
+		opts.serverReferences.push({ path: autoImports.importsModulePath + ".d.ts" });
+		opts.references.push({ path: autoImports.importsModulePath + ".d.ts" });
 		opts.tsConfig.exclude ||= [];
 		opts.tsConfig.exclude.push(relative(typesDir, resolve(nuxt.options.rootDir, nitro.options.output.dir)));
-		opts.tsConfig.exclude.push(relative(typesDir, resolve(nuxt.options.rootDir, nuxt.options.serverDir)));
-		opts.references.push({ path: resolve(nuxt.options.rootDir, nitroConfig.typescript.generatedTypesDir, "nitro.d.ts") });
+		opts.serverTsConfig.exclude ||= [];
+		opts.serverTsConfig.exclude.push(relative(typesDir, resolve(nuxt.options.rootDir, nitro.options.output.dir)));
+		opts.serverReferences.push({ path: resolve(typesDir, "types/nitro-nuxt.d.ts") });
+		opts.serverTsConfig.compilerOptions ||= {};
+		opts.serverTsConfig.compilerOptions.paths ||= {};
+		const serverPaths = opts.serverTsConfig.compilerOptions.paths;
+		const serverBaseUrl = nuxt.options.future.compatibilityVersion >= 5 ? void 0 : opts.serverTsConfig.compilerOptions.baseUrl;
+		const aliasBasePath = serverBaseUrl ? resolve(typesDir, serverBaseUrl) : typesDir;
+		for (const alias in nitro.options.alias) {
+			if (alias in nuxt.options.alias || alias in serverPaths) continue;
+			if (excludedServerAlias.some((pattern) => typeof pattern === "string" ? alias === pattern : pattern.test(alias))) continue;
+			const target = nitro.options.alias[alias];
+			let absolutePath = resolve(aliasBasePath, target);
+			let stats = await promises.stat(absolutePath).catch(() => null);
+			if (!stats) {
+				const resolvedModule = resolveModulePath(target, {
+					try: true,
+					from: nuxt.options.modulesDir.map((d) => pathToFileURL(withTrailingSlash(d))),
+					extensions: [
+						...nuxt.options.extensions,
+						".d.ts",
+						".d.mts",
+						".d.cts"
+					]
+				});
+				if (resolvedModule) {
+					absolutePath = resolvedModule;
+					stats = await promises.stat(resolvedModule).catch(() => null);
+				}
+			}
+			serverPaths[alias] = [absolutePath];
+			if (target.endsWith("/") || stats?.isDirectory()) serverPaths[`${alias}/*`] = [`${absolutePath}/*`];
+		}
+		const appDir = nuxt.options.alias["#app"];
+		if (appDir) {
+			serverPaths["#app/island-hash"] ||= [resolve(appDir, "island-hash")];
+			serverPaths["#app/island-props"] ||= [resolve(appDir, "island-props")];
+			serverPaths["#app/internal/*"] ||= [resolve(appDir, "internal/*")];
+			serverPaths["#app/types"] ||= [resolve(appDir, "types")];
+		}
 		opts.tsConfig.compilerOptions ||= {};
 		opts.tsConfig.compilerOptions.paths ||= {};
 		opts.tsConfig.compilerOptions.paths[REQUEST_TYPES_MODULE] = [resolve(distDir, "request-types")];

package/dist/runtime/utils/renderer/early-404.mjs

@@ -29,7 +29,7 @@ function matchesPageRoute(pathname) {
 function throwIfUnmatchedPagePath(event, routeOptions) {
 	if (matchesPageRoute(event.url.pathname)) return;
 	const path = event.url.pathname + event.url.search;
-	const maxAge = routeOptions.cache?.options?.maxAge;
+	const maxAge = routeOptions.cache?.maxAge;
 	const cacheable = !!maxAge && maxAge > 0 && (event.req.method === "GET" || event.req.method === "HEAD");
 	throw new HTTPError({
 		status: 404,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/nitro-server-nightly",
-  "version": "5.0.0-29807919.2cbde35e",
+  "version": "5.0.0-29809859.f0ca99e9",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -36,7 +36,7 @@
   ],
   "dependencies": {
     "@ampproject/remapping": "^2.3.0",
-    "@nuxt/kit": "npm:@nuxt/kit-nightly@5.0.0-29807919.2cbde35e",
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@5.0.0-29809859.f0ca99e9",
     "@unhead/vue": "^3.4.0",
     "@vue/shared": "^3.5.42",
     "consola": "^3.4.2",
@@ -51,17 +51,19 @@
     "lru-cache": "^11.5.2",
     "magic-string": "^1.2.3",
     "mocked-exports": "^0.1.1",
-    "nitro": "^3.0.260610-beta",
+    "nitro": "^3.0.260903-beta",
     "nostics": "^1.2.0",
     "ohash": "^2.0.12",
     "pathe": "^2.0.3",
     "rou3": "^0.9.2",
-    "srvx": "0.11.22",
+    "srvx": "^1.0.3",
     "std-env": "^4.2.0",
     "ufo": "^1.6.4",
     "unctx": "^3.0.1",
+    "unimport": "6.4.0",
+    "unplugin": "^3.3.0",
     "unrouting": "^0.2.3",
-    "unstorage": "2.0.0-alpha.7",
+    "unstorage": "^2.0.0-alpha.10",
     "vue": "^3.5.42",
     "vue-bundle-renderer": "^2.3.2",
     "vue-devtools-stub": "^0.1.0"
@@ -70,7 +72,7 @@
     "@babel/plugin-proposal-decorators": "^7.25.0 || ^8.0.0",
     "@babel/plugin-syntax-typescript": "^7.25.0 || ^8.0.0",
     "@rollup/plugin-babel": "^6.0.0 || ^7.0.0",
-    "nuxt": "npm:nuxt-nightly@5.0.0-29807919.2cbde35e"
+    "nuxt": "npm:nuxt-nightly@5.0.0-29809859.f0ca99e9"
   },
   "peerDependenciesMeta": {
     "@babel/plugin-proposal-decorators": {
@@ -86,10 +88,10 @@
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "8.0.2",
     "@babel/plugin-syntax-typescript": "8.0.3",
-    "@nuxt/schema": "npm:@nuxt/schema-nightly@5.0.0-29807919.2cbde35e",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@5.0.0-29809859.f0ca99e9",
     "@rollup/plugin-babel": "7.1.0",
     "hookable": "^6.1.1",
-    "nuxt": "npm:nuxt-nightly@5.0.0-29807919.2cbde35e",
+    "nuxt": "npm:nuxt-nightly@5.0.0-29809859.f0ca99e9",
     "tsdown": "0.22.14",
     "vitest": "4.1.11"
   },