Development Server

/**
 * Vite-node plugin for SSR development
 * Provides seamless SSR development with hot module replacement for server code
 * @param nuxt - Nuxt instance with development configuration
 * @returns Vite plugin instance for vite-node integration
 */
function ViteNodePlugin(nuxt: Nuxt): Plugin;

import { ViteNodePlugin } from "@nuxt/vite-builder/vite-node";
import type { Nuxt } from "@nuxt/schema";

// Used internally during client build setup
const plugin = ViteNodePlugin(nuxt);

// Enables:
// - Server-side hot module replacement
// - Real-time server code transformation
// - Seamless SSR development experience

/**
 * Write development server configuration
 * Creates development server setup for Nitro integration with proper middleware
 * @param nuxt - Nuxt instance with server configuration
 */
function writeDevServer(nuxt: Nuxt): Promise<void>;

/**
 * Vite-Node request mapping interface
 * Defines request/response types for vite-node communication
 */
interface ViteNodeRequestMap {
  /** Manifest request for client bundle information */
  manifest: {
    request: undefined;
    response: Manifest;
  };
  /** Invalidation request for cache clearing */
  invalidates: {
    request: undefined;
    response: string[];
  };
  /** Module resolution request */
  resolve: {
    request: { id: string; importer?: string };
    response: ResolveIdResponse | null;
  };
  /** Module transformation request */
  module: {
    request: { moduleId: string };
    response: FetchResult;
  };
}

/**
 * Request type helper for vite-node requests
 */
type RequestOf = {
  [K in keyof ViteNodeRequestMap]: {
    id: number;
    type: K;
    payload: ViteNodeRequestMap[K]['request'];
  };
}[keyof ViteNodeRequestMap];

/**
 * Vite-Node server for handling SSR transformations
 * Manages server-side module transformations and caching
 */
class ViteNodeServer {
  /** Transform server-side modules */
  transformRequest(id: string): Promise<FetchResult>;
  /** Resolve module dependencies */
  resolveId(id: string, importer?: string): Promise<ResolveIdResponse | null>;
  /** Invalidate module cache */
  invalidateModule(id: string): void;
}

/**
 * HMR configuration for development server
 */
interface HMRConfig {
  /** HMR protocol (ws/wss) */
  protocol?: 'ws' | 'wss';
  /** HMR server port */
  port?: number;
  /** Custom HMR server instance */
  server?: Server;
  /** HMR client options */
  clientPort?: number;
}

/**
 * Development middleware handler
 * Integrates Vite dev server with Nuxt's middleware system
 */
interface DevMiddleware {
  /** Handle incoming requests through Vite middleware */
  handle(req: IncomingMessage, res: ServerResponse): Promise<void>;
  /** Skip Vite transformation for specific requests */
  skipTransform(req: IncomingMessage & { _skip_transform?: boolean }): void;
}

/**
 * File watching configuration
 */
interface WatchOptions {
  /** Files and directories to watch */
  include?: string[];
  /** Files and directories to ignore */
  exclude?: string[];
  /** Chokidar options for file watching */
  chokidar?: ChokidarOptions;
}

/**
 * Development error information
 */
interface DevError {
  /** Error message */
  message: string;
  /** Error stack trace */
  stack?: string;
  /** File location of error */
  loc?: { file: string; line: number; column: number };
  /** Error type/category */
  type: 'transform' | 'resolve' | 'syntax' | 'runtime';
}

/**
 * Warmup Vite server with entry files
 * Pre-transforms entry files for faster initial loading
 * @param server - Vite development server
 * @param entries - Array of entry file paths
 * @param isServer - Whether this is for server-side code
 */
function warmupViteServer(
  server: ViteDevServer, 
  entries: string[], 
  isServer: boolean
): Promise<void>;

/**
 * Create custom Vite logger
 * Creates logger with Nuxt-specific formatting and filtering
 * @param config - Vite configuration
 * @param options - Logger options
 * @returns Custom logger instance
 */
function createViteLogger(
  config: ViteConfig, 
  options?: { hideOutput?: boolean }
): Logger;

// Development server configuration
const devConfig = {
  server: {
    middlewareMode: true,
    warmup: {
      clientFiles: [ctx.entry],
      ssrFiles: [serverEntry]
    },
    watch: {
      ...nuxt.options.watchers.chokidar,
      ignored: [isIgnored, /[\\/]node_modules[\\/]/]
    },
    fs: {
      allow: [...new Set(allowDirs)]
    }
  }
};