@adonisjs/vite 5.1.1 → 6.0.0-next.1

package/build/src/client/reload.d.ts

@@ -0,0 +1,13 @@
+import { type Plugin } from 'vite';
+export interface ReloadOptions {
+    delay?: number;
+}
+/**
+ * Returns a Vite plugin that triggers a full browser reload whenever any file
+ * matching the supplied glob patterns changes. Patterns are resolved relative
+ * to the Vite project root.
+ *
+ * Replaces the previous `vite-plugin-restart` dependency. Only the reload
+ * (browser refresh) feature is implemented — server restart is not.
+ */
+export declare function reload(patterns: string | string[], options?: ReloadOptions): Plugin;

package/build/src/client/resolve_assets.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+import type { PluginOptions } from './types.ts';
+/**
+ * Returns a plugin that emits user-supplied files into the build output.
+ *
+ * `chunks` are passed to Vite's `emitFile({ type: 'chunk' })` after glob
+ * expansion. They are processed by the bundler and surface in the manifest
+ * with hashed filenames.
+ *
+ * `assets` are emitted as raw `type: 'asset'` files (no glob expansion —
+ * exact paths only) so the original source content is preserved verbatim.
+ * The `originalFileName` field tells Vite to use the source path as the
+ * manifest key, so templates can resolve them via
+ * `vite.assetPath('resources/images/logo.png')` without any post-build
+ * manifest rewriting.
+ *
+ * Returns an empty array (no-op) when neither chunks nor assets are
+ * configured.
+ */
+export declare function resolveAssets(input: PluginOptions['assets']): Plugin[];

package/build/src/client/types.d.ts

@@ -22,5 +22,30 @@ export interface PluginOptions {
      * @default 'public/assets'
      */
     buildDirectory?: string;
+    /**
+     * Server-side entrypoints bundled into the SSR build output. Each
+     * entry is emitted as a single bundle (no hash, no shared chunks)
+     * under `<buildDirectory>/server/<name>.js` and becomes loadable
+     * through `vite.loadServerModule()` at runtime.
+     *
+     * Paths are relative to the project root.
+     */
+    serverEntrypoints?: string[];
+    /**
+     * Additional files to include in the build that are not imported by the
+     * entrypoints.
+     *
+     * - When passed as a `string[]`, every entry is treated as a chunk: glob
+     *   patterns are expanded and each matching file is emitted via Vite's
+     *   `emitFile({ type: 'chunk' })`.
+     * - When passed as `{ chunks?, assets? }`, `chunks` behaves identically
+     *   to the array form, while `assets` files are emitted as raw assets
+     *   (no glob support, exact paths only) and the manifest is rewritten so
+     *   the manifest key matches the source path.
+     */
+    assets?: string[] | {
+        chunks?: string[];
+        assets?: string[];
+    };
 }
-export type PluginFullOptions = Required<PluginOptions>;
+export type PluginFullOptions = Required<Omit<PluginOptions, 'assets'>>;

package/build/src/hooks/build_hook.js

@@ -8,8 +8,17 @@ import { createBuilder } from "vite";
 * The hook is responsible for launching a Vite multi-build process.
 */
 var build_hook_default = hooks.buildStarting(async (parent) => {
+	/**
+	* Vite's CLI sets NODE_ENV to 'production' automatically when running
+	* `vite build`, but the programmatic `createBuilder` API does not.
+	* Without this, framework plugins (React, Vue, MDX, …) emit dev-only
+	* code paths in the production bundle.
+	*
+	* See https://github.com/remix-run/remix/issues/4081
+	*/
+	process.env.NODE_ENV = "production";
 	parent.ui.logger.info("building assets with vite");
-	await (await createBuilder({}, null)).buildApp();
+	await (await createBuilder({}, false)).buildApp();
 });
 //#endregion
 export { build_hook_default as default };

package/build/src/server_modules/bundled_module_resolver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolves and imports server-side modules from the production SSR build.
+ *
+ * In production there is no Vite dev server — entrypoints declared as
+ * `serverEntrypoints` are pre-built into `<buildDirectory>/server` and
+ * recorded in `<buildDirectory>/server/.vite/manifest.json`. The
+ * resolver reads that manifest to map an entry source path to the
+ * emitted bundle file, then imports it through Node's native `import()`.
+ *
+ * Imports are cached per entry so repeated calls reuse the same module
+ * instance and side-effects only run once.
+ */
+export declare class BundledModuleResolver {
+    #private;
+    constructor(buildDirectory: string);
+    import<T>(entry: string): Promise<T>;
+}

package/build/src/server_modules/dev_module_runner.d.ts

@@ -0,0 +1,25 @@
+import type { ViteDevServer } from 'vite';
+import type { ModuleRunner } from 'vite/module-runner';
+import type { LoadServerModuleOptions } from '../types.ts';
+/**
+ * Hosts the Vite `ModuleRunner` used to evaluate server-side modules in
+ * development mode.
+ *
+ * Owns a single shared runner across all `loadServerModule` calls, and
+ * detects Vite dev server restarts (which replace `server.environments.ssr`
+ * with a fresh instance) so the stale runner is closed and recreated.
+ */
+export declare class DevModuleRunner {
+    #private;
+    constructor(createRunner: () => Promise<ModuleRunner>);
+    /**
+     * Imports a module through the runner. Recreates the runner if the
+     * dev server's SSR environment was swapped underneath us.
+     */
+    import<T>(server: ViteDevServer, entry: string, opts: LoadServerModuleOptions): Promise<T>;
+    /**
+     * Closes the runner, if any. Safe to call when no runner has been
+     * created yet.
+     */
+    close(): Promise<void>;
+}

package/build/src/server_modules/server_module_loader.d.ts

@@ -0,0 +1,25 @@
+import type { ViteDevServer } from 'vite';
+import type { ModuleRunner } from 'vite/module-runner';
+import type { LoadServerModuleOptions } from '../types.ts';
+/**
+ * Public entry point for loading server-side modules processed by Vite.
+ *
+ * Picks between two collaborators based on whether the Vite dev server
+ * is running:
+ *
+ * - In development, delegates to {@link DevModuleRunner} which evaluates
+ *   the entry through Vite's `ModuleRunner`, with HMR-driven cache
+ *   invalidation.
+ * - In production, delegates to {@link BundledModuleResolver} which
+ *   imports the pre-built bundle from disk.
+ *
+ * Entry strings are passed through verbatim to mirror how client
+ * `entrypoints` are handled — the caller is responsible for using the
+ * exact string declared in `serverEntrypoints`.
+ */
+export declare class ServerModuleLoader {
+    #private;
+    constructor(getDevServer: () => ViteDevServer | undefined, buildDirectory: string, createRunner: () => Promise<ModuleRunner>);
+    load<T>(entry: string, opts?: LoadServerModuleOptions): Promise<T>;
+    close(): Promise<void>;
+}

package/build/src/types.d.ts

@@ -54,3 +54,35 @@ export interface ViteOptions {
      */
     scriptAttributes?: SetAttributes;
 }
+/**
+ * Augmentable map for typing entries passed to `vite.loadServerModule`.
+ * Apps and packages merge into this interface to associate entrypoint
+ * paths with the shape of their default exports.
+ *
+ * @example
+ * declare module '@adonisjs/vite/types' {
+ *   interface ServerModuleMap {
+ *     'inertia/app/ssr.ts': typeof import('../inertia/app/ssr.ts')
+ *   }
+ * }
+ */
+export interface ServerModuleMap {
+}
+/**
+ * Options accepted by `vite.loadServerModule`.
+ */
+export interface LoadServerModuleOptions {
+    /**
+     * Clear the module runner cache before importing in dev mode.
+     *
+     * Defaults to `false` — Vite's HMR pushes invalidations into the
+     * runner, so cached modules are already kept fresh on file change.
+     * Set to `true` only when the entrypoint registers top-level state
+     * that must be reset on every load.
+     *
+     * Has no effect in production (bundled imports are always cached).
+     *
+     * @default false
+     */
+    fresh?: boolean;
+}

package/build/src/vite.d.ts

@@ -1,6 +1,6 @@
 import { type ModuleRunner } from 'vite/module-runner';
 import type { Manifest, InlineConfig, ViteDevServer, ServerModuleRunnerOptions } from 'vite';
-import type { AdonisViteElement, ViteOptions } from './types.ts';
+import type { AdonisViteElement, LoadServerModuleOptions, ServerModuleMap, ViteOptions } from './types.ts';
 /**
  * Vite class exposes the APIs to generate tags and URLs for
  * assets processed using vite.
@@ -111,6 +111,27 @@ export declare class Vite {
      * const mod = await runner.import('./app.js')
      */
     createModuleRunner(options?: ServerModuleRunnerOptions): Promise<ModuleRunner>;
+    /**
+     * Loads a server-side module that has been processed by Vite.
+     *
+     * In development, the entry is evaluated through Vite's `ModuleRunner`,
+     * giving full TypeScript / JSX / plugin support and HMR-driven cache
+     * invalidation. In production, the entry is imported from the
+     * pre-built SSR bundle on disk.
+     *
+     * The entry path must be declared in `serverEntrypoints` for the
+     * production import to succeed — otherwise the bundle won't exist.
+     *
+     * @example
+     * const mod = await vite.loadServerModule('inertia/app/ssr.ts')
+     * const html = await mod.default(payload)
+     *
+     * @example
+     * // Force re-evaluation (clear runner cache before import)
+     * await vite.loadServerModule('emails/welcome.ts', { fresh: true })
+     */
+    loadServerModule<K extends keyof ServerModuleMap>(entry: K, opts?: LoadServerModuleOptions): Promise<ServerModuleMap[K]>;
+    loadServerModule<T = unknown>(entry: string, opts?: LoadServerModuleOptions): Promise<T>;
     /**
      * Gracefully stops the Vite development server
      *

package/build/src/vite_middleware.d.ts

@@ -12,6 +12,7 @@ import type { Vite } from './vite.ts';
  * AdonisJS server.
  */
 export default class ViteMiddleware {
+    #private;
     protected vite: Vite;
     /**
      * Creates a new ViteMiddleware instance

package/build/src/vite_middleware.js

@@ -1,2 +1,2 @@
-import { t as ViteMiddleware } from "../vite_middleware-Bszg_DDr.js";
+import { t as ViteMiddleware } from "../vite_middleware-CuOBHhnt.js";
 export { ViteMiddleware as default };

package/build/{vite-DDpuL-Eo.js → vite-De-RhsJ1.js}

@@ -2,6 +2,148 @@ import { n as makeAttributes, r as uniqBy } from "./utils-CdZpa_tV.js";
 import { join } from "node:path";
 import string from "@poppinss/utils/string";
 import { existsSync, readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+//#region src/server_modules/dev_module_runner.ts
+/**
+* Hosts the Vite `ModuleRunner` used to evaluate server-side modules in
+* development mode.
+*
+* Owns a single shared runner across all `loadServerModule` calls, and
+* detects Vite dev server restarts (which replace `server.environments.ssr`
+* with a fresh instance) so the stale runner is closed and recreated.
+*/
+var DevModuleRunner = class {
+	/**
+	* Shared module runner. Lazy-created on first import.
+	*/
+	#runner;
+	/**
+	* Reference to the SSR environment the current runner was created from.
+	* When Vite restarts the dev server, `server.environments.ssr` is
+	* replaced — we use this reference to detect that and recreate.
+	*/
+	#ssrEnvironment;
+	/**
+	* Factory provided by the orchestrator to lazily create the runner.
+	* Indirection keeps this class decoupled from how the runner is built.
+	*/
+	#createRunner;
+	constructor(createRunner) {
+		this.#createRunner = createRunner;
+	}
+	/**
+	* Imports a module through the runner. Recreates the runner if the
+	* dev server's SSR environment was swapped underneath us.
+	*/
+	async import(server, entry, opts) {
+		const currentSsrEnv = server.environments.ssr;
+		if (this.#ssrEnvironment !== currentSsrEnv) {
+			if (this.#runner) await this.#runner.close();
+			this.#runner = void 0;
+			this.#ssrEnvironment = currentSsrEnv;
+		}
+		this.#runner ??= await this.#createRunner();
+		if (opts.fresh) this.#runner.clearCache();
+		return this.#runner.import(entry);
+	}
+	/**
+	* Closes the runner, if any. Safe to call when no runner has been
+	* created yet.
+	*/
+	async close() {
+		if (this.#runner) {
+			await this.#runner.close();
+			this.#runner = void 0;
+			this.#ssrEnvironment = void 0;
+		}
+	}
+};
+//#endregion
+//#region src/server_modules/bundled_module_resolver.ts
+/**
+* Resolves and imports server-side modules from the production SSR build.
+*
+* In production there is no Vite dev server — entrypoints declared as
+* `serverEntrypoints` are pre-built into `<buildDirectory>/server` and
+* recorded in `<buildDirectory>/server/.vite/manifest.json`. The
+* resolver reads that manifest to map an entry source path to the
+* emitted bundle file, then imports it through Node's native `import()`.
+*
+* Imports are cached per entry so repeated calls reuse the same module
+* instance and side-effects only run once.
+*/
+var BundledModuleResolver = class {
+	/**
+	* Absolute path to `<buildDirectory>/server`.
+	*/
+	#serverDir;
+	/**
+	* Cache of in-flight or resolved module imports, keyed by entry.
+	* Stores the promise so concurrent callers share the same import.
+	*/
+	#cache = /* @__PURE__ */ new Map();
+	/**
+	* Lazily-loaded manifest contents. Loaded once on first import call.
+	*/
+	#manifest;
+	constructor(buildDirectory) {
+		this.#serverDir = join(buildDirectory, "server");
+	}
+	async import(entry) {
+		let pending = this.#cache.get(entry);
+		if (!pending) {
+			const chunk = this.#readManifest()[entry];
+			if (!chunk) throw new Error(`Cannot loadServerModule("${entry}"): no chunk for this entry in the SSR manifest. Make sure the entry is declared in serverEntrypoints and the application has been rebuilt.`);
+			pending = import(pathToFileURL(join(this.#serverDir, chunk.file)).href);
+			this.#cache.set(entry, pending);
+		}
+		return pending;
+	}
+	#readManifest() {
+		if (this.#manifest) return this.#manifest;
+		const manifestPath = join(this.#serverDir, ".vite/manifest.json");
+		if (!existsSync(manifestPath)) throw new Error(`SSR manifest not found at ${manifestPath}. Build the application with at least one declared serverEntrypoint before loading server modules.`);
+		this.#manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+		return this.#manifest;
+	}
+};
+//#endregion
+//#region src/server_modules/server_module_loader.ts
+/**
+* Public entry point for loading server-side modules processed by Vite.
+*
+* Picks between two collaborators based on whether the Vite dev server
+* is running:
+*
+* - In development, delegates to {@link DevModuleRunner} which evaluates
+*   the entry through Vite's `ModuleRunner`, with HMR-driven cache
+*   invalidation.
+* - In production, delegates to {@link BundledModuleResolver} which
+*   imports the pre-built bundle from disk.
+*
+* Entry strings are passed through verbatim to mirror how client
+* `entrypoints` are handled — the caller is responsible for using the
+* exact string declared in `serverEntrypoints`.
+*/
+var ServerModuleLoader = class {
+	#getDevServer;
+	#devRunner;
+	#bundled;
+	constructor(getDevServer, buildDirectory, createRunner) {
+		this.#getDevServer = getDevServer;
+		this.#devRunner = new DevModuleRunner(createRunner);
+		this.#bundled = new BundledModuleResolver(buildDirectory);
+	}
+	async load(entry, opts = {}) {
+		const server = this.#getDevServer();
+		if (server) return this.#devRunner.import(server, entry, opts);
+		return this.#bundled.import(entry);
+	}
+	async close() {
+		await this.#devRunner.close();
+	}
+};
+//#endregion
 //#region src/vite.ts
 const STYLE_FILE_REGEX = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;
 /**
@@ -17,6 +159,11 @@ var Vite = class {
 	#options;
 	#devServer;
 	/**
+	* Loads server-side TypeScript modules through Vite. Picks between
+	* the dev `ModuleRunner` and the production SSR bundle automatically.
+	*/
+	#serverModuleLoader;
+	/**
 	* Indicates whether the Vite manifest file exists on disk
 	*/
 	hasManifestFile;
@@ -39,6 +186,7 @@ var Vite = class {
 		this.#options = options;
 		this.#options.assetsUrl = (this.#options.assetsUrl || "/").replace(/\/$/, "");
 		this.hasManifestFile = existsSync(this.#options.manifestFile);
+		this.#serverModuleLoader = new ServerModuleLoader(() => this.#devServer, this.#options.buildDirectory, () => this.createModuleRunner());
 	}
 	/**
 	* Reads the file contents as JSON
@@ -168,11 +316,17 @@ var Vite = class {
 		const tags = entryPoints.map((entrypoint) => this.#generateTag(entrypoint, attributes));
 		const jsEntrypoints = entryPoints.filter((entrypoint) => !this.#isCssPath(entrypoint));
 		/**
-		* If the module graph is empty, that means we didn't execute the entrypoint
-		* yet : we just started the AdonisJS dev server.
-		* So let's execute the entrypoints to populate the module graph
+		* If the client module graph is empty, that means we didn't execute the
+		* entrypoint yet : we just started the AdonisJS dev server. So let's
+		* execute the entrypoints to populate the client module graph.
+		*
+		* Use the per-environment client graph instead of the backward-compat
+		* `server.moduleGraph` union (client + ssr). Otherwise an SSR runner
+		* (e.g. @adonisjs/inertia rendering before @vite()) populates the ssr
+		* graph, the union check returns non-empty, the client warmup is
+		* skipped, and no <link rel="stylesheet"> tags are emitted.
 		*/
-		if (server?.moduleGraph.idToModuleMap.size === 0) await Promise.allSettled(jsEntrypoints.map((entrypoint) => server.warmupRequest(`/${entrypoint}`)));
+		if (server?.environments.client.moduleGraph.idToModuleMap.size === 0) await Promise.allSettled(jsEntrypoints.map((entrypoint) => server.warmupRequest(`/${entrypoint}`)));
 		/**
 		* We need to collect the CSS files imported by the entrypoints
 		* Otherwise, we gonna have a FOUC each time we full reload the page
@@ -186,7 +340,7 @@ var Vite = class {
 		*/
 		for (const entryPoint of jsEntrypoints) {
 			const filePath = join(server.config.root, entryPoint);
-			const entryMod = server.moduleGraph.getModuleById(string.toUnixSlash(filePath));
+			const entryMod = server.environments.client.moduleGraph.getModuleById(string.toUnixSlash(filePath));
 			if (entryMod) this.#collectCss(entryMod, preloadUrls, visitedModules);
 		}
 		Array.from(preloadUrls).map((href) => this.#generateElement({
@@ -408,6 +562,9 @@ var Vite = class {
 		const { createServerModuleRunner } = await import("vite");
 		return createServerModuleRunner(this.#devServer.environments.ssr, options);
 	}
+	loadServerModule(entry, opts) {
+		return this.#serverModuleLoader.load(entry, opts);
+	}
 	/**
 	* Gracefully stops the Vite development server
 	*
@@ -417,6 +574,7 @@ var Vite = class {
 	* await vite.stopDevServer()
 	*/
 	async stopDevServer() {
+		await this.#serverModuleLoader.close();
 		await this.#devServer?.close();
 	}
 	/**

package/build/{vite_middleware-Bszg_DDr.js → vite_middleware-CuOBHhnt.js}

@@ -10,6 +10,7 @@
 * AdonisJS server.
 */
 var ViteMiddleware = class {
+	#devServer;
 	/**
 	* Creates a new ViteMiddleware instance
 	*
@@ -20,6 +21,7 @@ var ViteMiddleware = class {
 	*/
 	constructor(vite) {
 		this.vite = vite;
+		this.#devServer = this.vite.getDevServer();
 	}
 	/**
 	* Handles HTTP requests by proxying them to the Vite dev server when appropriate
@@ -32,8 +34,7 @@ var ViteMiddleware = class {
 	* await middleware.handle(ctx, next)
 	*/
 	async handle({ request, response }, next) {
-		const devServer = this.vite.getDevServer();
-		if (!devServer) return next();
+		if (!this.#devServer) return next();
 		return new Promise((resolve, reject) => {
 			function done(error) {
 				response.response.removeListener("finish", done);
@@ -50,7 +51,7 @@ var ViteMiddleware = class {
 			* to Node.js.
 			*/
 			response.relayHeaders();
-			devServer.middlewares.handle(request.request, response.response, async () => {
+			this.#devServer.middlewares.handle(request.request, response.response, async () => {
 				/**
 				* This callback is invoked when Vite does not handle the request. In that
 				* case, we will call next and resolve this promise. Also we remove the

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/vite",
   "description": "Vite plugin for AdonisJS",
-  "version": "5.1.1",
+  "version": "6.0.0-next.1",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -44,11 +44,11 @@
     "docs": "typedoc"
   },
   "devDependencies": {
-    "@adonisjs/assembler": "^8.0.0",
-    "@adonisjs/core": "^7.0.0",
+    "@adonisjs/assembler": "^8.4.0",
+    "@adonisjs/core": "^7.3.2",
     "@adonisjs/eslint-config": "^3.0.0",
     "@adonisjs/prettier-config": "^1.4.5",
-    "@adonisjs/session": "^8.0.0",
+    "@adonisjs/session": "^8.1.0",
     "@adonisjs/shield": "^9.0.0",
     "@adonisjs/tsconfig": "^2.0.0",
     "@japa/assert": "4.2.0",
@@ -56,34 +56,35 @@
     "@japa/runner": "5.3.0",
     "@japa/snapshot": "^2.0.10",
     "@poppinss/ts-exec": "^1.4.4",
-    "@release-it/conventional-changelog": "^10.0.5",
-    "@types/node": "^25.3.0",
-    "@types/supertest": "^6.0.3",
+    "@release-it/conventional-changelog": "^11.0.0",
+    "@types/node": "^25.6.0",
+    "@types/picomatch": "^4.0.3",
+    "@types/supertest": "^7.2.0",
     "c8": "^11.0.0",
     "copyfiles": "^2.4.1",
     "cross-env": "^10.1.0",
     "del-cli": "^7.0.0",
     "edge.js": "^6.5.0",
-    "eslint": "^10.0.2",
-    "prettier": "^3.8.1",
-    "release-it": "^19.2.4",
+    "eslint": "^10.3.0",
+    "prettier": "^3.8.3",
+    "release-it": "^20.0.1",
     "supertest": "^7.2.2",
-    "tsdown": "^0.21.2",
-    "typedoc": "^0.28.17",
-    "typescript": "~5.9.3",
-    "vite": "^7.3.1"
+    "tsdown": "^0.21.10",
+    "typedoc": "^0.28.19",
+    "typescript": "~6.0.3",
+    "vite": "^8.0.10"
   },
   "dependencies": {
-    "@poppinss/utils": "^7.0.0",
+    "@poppinss/utils": "^7.0.1",
     "edge-error": "^4.0.2",
-    "vite-plugin-restart": "^2.0.0"
+    "picomatch": "^4.0.4"
   },
   "peerDependencies": {
     "@adonisjs/assembler": "^8.0.0-next.10 || ^8.0.0",
     "@adonisjs/core": "^7.0.0-next.3 || ^7.0.0",
     "@adonisjs/shield": "^9.0.0-next.0 || ^9.0.0",
     "edge.js": "^6.0.1",
-    "vite": "^7.0.0"
+    "vite": "^8.0.0"
   },
   "peerDependenciesMeta": {
     "edge.js": {