@solidjs/vite-plugin 3.0.0-next.31 → 3.0.0-next.32

package/dist/esm/index.mjs

@@ -6,7 +6,7 @@ import { mergeAndConcat } from 'merge-anything';
 import { createRequire } from 'module';
 import path from 'path';
 import { Readable } from 'node:stream';
-import { createFilter, normalizePath, loadEnv, version } from 'vite';
+import { createFilter, normalizePath, loadEnv, runnerImport, defaultClientConditions, defaultServerConditions } from 'vite';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { crawlFrameworkPkgs } from 'vitefu';
 
@@ -504,18 +504,18 @@ function boundaryModules() {
       // import graph — no directive transforms have run, so it walks
       // straight through 'use server' modules into genuinely server-only
       // code. That graph is legal once transforms split it, so the guard
-      // must not fire on the scan pass (`options.scan`, the flag Vite's
-      // scanner sets on plugin-container resolves in v6/7 and the rolldown
-      // scanner in v8). Still claim the specifier: resolving to the empty
+      // must not fire on the scan pass (`options.scan`, set by Rolldown's
+      // dependency scanner). Still claim the specifier: resolving to the empty
       // virtual module keeps the scanner from chasing `server-only` /
       // `client-only` as missing bare dependencies, which would abort the
       // scan all the same. Real dev/build module graphs resolve without
       // the flag and stay fully guarded.
       const scan = !!options?.scan;
+      const server = this.environment.config.consumer === 'server';
       if (id === 'server-only') {
-        if (!options?.ssr && !scan) this.error(`[@solidjs/vite-plugin] Attempt to import 'server-only' in a client module: ${importer}. ` + `Code that uses this module must run only on the server — make sure it is only ` + `imported by server code (e.g. a server entry, a "use server" module, or code ` + `reached exclusively from them).`);
+        if (!server && !scan) this.error(`[@solidjs/vite-plugin] Attempt to import 'server-only' in a client module: ${importer}. ` + `Code that uses this module must run only on the server — make sure it is only ` + `imported by server code (e.g. a server entry, a "use server" module, or code ` + `reached exclusively from them).`);
       } else if (id === 'client-only') {
-        if (options?.ssr && !scan) this.error(`[@solidjs/vite-plugin] Attempt to import 'client-only' in a server module: ${importer}. ` + `Code that uses this module must run only in the browser — make sure it is only ` + `imported by client code (e.g. behind a client-only lazy boundary).`);
+        if (server && !scan) this.error(`[@solidjs/vite-plugin] Attempt to import 'client-only' in a server module: ${importer}. ` + `Code that uses this module must run only in the browser — make sure it is only ` + `imported by client code (e.g. behind a client-only lazy boundary).`);
       } else {
         return null;
       }
@@ -818,8 +818,6 @@ function invalidateModule(moduleGraph, path) {
   }
 }
 function invalidateModules(server, result, manifest) {
-  // `environments` requires Vite 6+; older versions just miss the eager
-  // manifest invalidation (the debounced reload still converges).
   if (server?.environments && result.invalidPreload) {
     invalidateModule(server.environments.client.moduleGraph, manifest);
     invalidateModule(server.environments.ssr.moduleGraph, manifest);
@@ -1012,7 +1010,7 @@ function serverFunctions(options = {}, internal = {}) {
       apply: 'serve',
       configureServer(server) {
         const ssrEnvironment = server.environments.ssr;
-        if (internal.externalDevServer || ssrEnvironment && !isRunnableEnvironment(ssrEnvironment)) {
+        if (internal.externalDevServer || !isRunnableEnvironment(ssrEnvironment)) {
           return;
         }
         server.middlewares.use((req, res, next) => {
@@ -1035,7 +1033,7 @@ function serverFunctions(options = {}, internal = {}) {
             const functionId = (typeof headerId === 'string' ? headerId.split('#')[0] : undefined) || url.searchParams.get('id');
             if (functionId) {
               const entry = moduleForFunctionId(functionId);
-              if (entry) await server.ssrLoadModule(moduleDevUrl(entry));
+              if (entry) await ssrEnvironment.runner.import(moduleDevUrl(entry));
             }
             // Dispatch through a module evaluated in the SSR environment so
             // the handler shares the registry instance with the app modules.
@@ -1043,7 +1041,7 @@ function serverFunctions(options = {}, internal = {}) {
             // in, and dispatch goes through `handleRequest` instead — one
             // middleware chain and one stub-backed request event front the
             // endpoint exactly as they front page SSR.
-            const handler = await server.ssrLoadModule(internal.ssrHandler ?? HANDLER_ID$1);
+            const handler = await ssrEnvironment.runner.import(internal.ssrHandler ?? HANDLER_ID$1);
             // Both dispatch shapes carry the raw Node request on the event
             // (the `options.event` seam), matching the SSR dev middleware
             // and what a production Node entry passes.
@@ -1055,7 +1053,6 @@ function serverFunctions(options = {}, internal = {}) {
             const response = internal.ssrHandler ? await handler.handleRequest(webRequestFromNode(req, dispatchUrl, res), dispatchOptions) : await handler.handleServerFunctionRequest(webRequestFromNode(req, dispatchUrl, res), dispatchOptions);
             await sendWebResponse(res, response);
           })().catch(error => {
-            if (error instanceof Error) server.ssrFixStacktrace(error);
             next(error);
           });
         });
@@ -1179,13 +1176,9 @@ function serverFunctions(options = {}, internal = {}) {
 }
 
 const DEVTOOLS_PACKAGE = '@solidjs/start-devtools';
-const DEVTOOLS_ID = 'virtual:solid-devtools';
 const DEVTOOLS_MOUNT_ID = 'virtual:solid-devtools/mount';
-function devtoolsModuleCode() {
-  return [`import * as serverFunctions from '@solidjs/web/server-functions';`, `import { DevToolbar, pushServerFunctionCall } from '${DEVTOOLS_PACKAGE}';`, `const observe = Reflect.get(serverFunctions, 'observeServerFunctionCalls');`, `if (typeof observe === 'function') observe(pushServerFunctionCall);`, `export { DevToolbar };`].join('\n');
-}
 function devtoolsMountModuleCode() {
-  return [`import ${JSON.stringify(DEVTOOLS_ID)};`, `import { mountDevToolbar } from '${DEVTOOLS_PACKAGE}';`, `mountDevToolbar();`].join('\n');
+  return [`import { mountDevToolbar } from '${DEVTOOLS_PACKAGE}';`, `mountDevToolbar();`].join('\n');
 }
 
 // Start-mode serving for plain Vite apps: `solid({ start: {...} })` (or the
@@ -1202,7 +1195,7 @@ function devtoolsMountModuleCode() {
 //   Both paths inject the Vite client, dev style patch, and entry CSS as
 //   `<style data-vite-dev-id>` tags before the body can paint.
 // - Prod: the plugin configures a full-app build (client + server bundles
-//   via the Vite 6+ environments/builder API — a single `vite build` builds
+//   via the Vite environments/builder API — a single `vite build` builds
 //   both) whose server entry is `virtual:solid-ssr-handler`: an
 //   adapter-agnostic named `handleRequest(Request) => Promise<Response>` plus
 //   a default Fetchable `{ fetch(request) }` export. Both scope each request
@@ -1384,10 +1377,9 @@ function startServe(options, internal = {}) {
   const serverComponents = !!internal.serverComponents;
   const errorBoundary = options.errorBoundary !== false;
   const styleFilter = internal.styleFilter;
-  let devtools = false;
-  let devtoolsResolution;
-  /** Resolved module id of `@solidjs/start-devtools` once detection succeeds. */
-  let devtoolsId = null;
+  let devtoolsEnabled = false;
+  let devtoolsResolutions = {};
+  let devtoolsIds = {};
   // `external` is server-mode-only (documented no-op in client mode, so a
   // host-integrated config survives the `ssr` boolean flip untouched).
   const externalServer = !clientMode && !!options.external;
@@ -1404,31 +1396,36 @@ function startServe(options, internal = {}) {
     if (!entries) throw new Error('[@solidjs/vite-plugin] SSR entries not resolved yet');
     return entries;
   }
-  async function resolveDevtools(resolve, importer) {
-    if (devtools !== undefined) return devtools;
+  async function resolveDevtools(resolve, importer, consumer) {
+    if (!devtoolsEnabled) return false;
     // Detect from the app graph first (the documented install location), then
     // from the plugin's own file: in pnpm-isolated apps a copy that is only a
     // dependency of the plugin is not reachable from the app's importers. The
-    // resolved id is kept so the virtual modules' imports of the package can
-    // be delegated to it (see resolveId).
-    devtoolsResolution ??= (async () => ((await resolve(DEVTOOLS_PACKAGE, importer)) ?? (await resolve(DEVTOOLS_PACKAGE, fileURLToPath(import.meta.url))))?.id ?? null)();
-    devtoolsId = await devtoolsResolution;
-    devtools = devtoolsId !== null;
-    if (!devtools && options.devtools === true) {
+    // resolved id is kept so imports from generated modules can use it.
+    devtoolsResolutions[consumer] ??= (async () => {
+      // Resolving from the plugin's own file never yields null when the
+      // package is absent: it is declared an optional peer dependency, so
+      // Vite answers with its `__vite-optional-peer-dep:` stub (an empty
+      // module). Treat that stub as "not installed".
+      const realId = resolved => resolved && !resolved.id.startsWith('__vite-optional-peer-dep:') ? resolved.id : null;
+      return realId(await resolve(DEVTOOLS_PACKAGE, importer)) ?? realId(await resolve(DEVTOOLS_PACKAGE, fileURLToPath(import.meta.url)));
+    })();
+    const id = await devtoolsResolutions[consumer];
+    devtoolsIds[consumer] = id;
+    if (!id && options.devtools === true) {
       throw new Error('[@solidjs/vite-plugin] start.devtools requires @solidjs/start-devtools. ' + 'Install it as a development dependency or set start.devtools to false.');
     }
-    return devtools;
+    return id !== null;
   }
 
   /**
-   * Cheap root-walk probe mirroring how the optimizer resolves bare
+   * Cheap walk-up probe mirroring how the optimizer resolves bare
    * `optimizeDeps.include` entries: is @solidjs/start-devtools reachable from
-   * the Vite root? Detection proper (resolveDevtools) runs later with a real
+   * this directory? Detection proper (resolveDevtools) runs later with a real
    * importer; this only decides whether the toolbar graph can be pre-bundled
-   * at scan time — it hangs off virtual modules the scanner never sees, so
-   * first-request discovery would force a re-optimize + full page reload.
+   * at scan time.
    */
-  function devtoolsReachableFromRoot(dir) {
+  function devtoolsReachableFrom(dir) {
     for (let current = dir;;) {
       if (existsSync(path.join(current, 'node_modules', DEVTOOLS_PACKAGE, 'package.json'))) {
         return true;
@@ -1439,6 +1436,26 @@ function startServe(options, internal = {}) {
     }
   }
 
+  /**
+   * The `optimizeDeps.include` spec that pre-bundles the toolbar graph, or
+   * null when it cannot be resolved at all. Pre-bundling it is not just a
+   * warm-start nicety: the toolbar hangs off virtual modules the scanner
+   * never crawls, so without an include the optimizer only discovers it on
+   * first request. That re-optimize can pair chunks from different passes
+   * whose shared minified exports disagree, taking down the whole client
+   * entry graph. The spec must therefore cover every install shape
+   * resolveDevtools accepts: bare when the app installs the package, and
+   * Vite's nested-include form (`plugin > dep`) when it is only a dependency
+   * of this plugin (pnpm-isolated installs).
+   */
+  function devtoolsIncludeSpec(rootDir) {
+    if (devtoolsReachableFrom(rootDir)) return DEVTOOLS_PACKAGE;
+    if (devtoolsReachableFrom(path.dirname(fileURLToPath(import.meta.url)))) {
+      return `@solidjs/vite-plugin > ${DEVTOOLS_PACKAGE}`;
+    }
+    return null;
+  }
+
   /** Import specifier for generated code: absolute for files, id for virtuals. */
   function entryServerSpec() {
     const {
@@ -1492,7 +1509,7 @@ function startServe(options, internal = {}) {
     const content = wrapper ? `<${wrapper}><${root} /></${wrapper}>` : `<${root} />`;
     return isBuild && errorBoundary ? [`  <DefaultErrorBoundary>`, `    <Document>`, `      <DefaultErrorBoundary>`, `        ${content}`, `      </DefaultErrorBoundary>`, `    </Document>`, `  </DefaultErrorBoundary>`] : [`  <Document>`, `    ${content}`, `  </Document>`];
   }
-  function generatedEntryServerCode() {
+  function generatedEntryServerCode(toolbar) {
     if (clientMode) {
       // The client-mode shell: the document without the app. Rendered per
       // request in dev (any HTML GET gets it — history-fallback semantics)
@@ -1504,7 +1521,7 @@ function startServe(options, internal = {}) {
       app
     } = requireEntries();
     const streamOptions = `{ manifest${serverComponents ? ', plugins: [ServerComponentPlugin]' : ''} }`;
-    return [`import { renderToStream${setupPath ? ', getRequestEvent' : ''} } from '@solidjs/web';`, ...(serverComponents ? [`import { configureServerFunctionsServer } from '@solidjs/web/server-functions';`, `import { frameTransformDirectResult, ServerComponentPlugin } from '@solidjs/web/frames';`] : []), `import manifest from ${JSON.stringify(MANIFEST_ID)};`, `import Document from ${JSON.stringify(documentSpec())};`, `import App from ${JSON.stringify(app)};`, ...errorBoundaryImport(), ...(setupPath ? [`import setup from ${JSON.stringify(setupPath)};`] : []), ``, ...(setupPath ? [`if (typeof setup !== 'function') {`, `  throw new Error('[@solidjs/vite-plugin] start.setup must default-export a function ' +`, `    '((event, App) => Component | void | Promise<...>): ' + ${JSON.stringify(options.setup)});`, `}`, ``] : []), ...(serverComponents ? [
+    return [`import { renderToStream${setupPath ? ', getRequestEvent' : ''} } from '@solidjs/web';`, ...(serverComponents ? [`import { configureServerFunctionsServer } from '@solidjs/web/server-functions';`, `import { frameTransformDirectResult, ServerComponentPlugin } from '@solidjs/web/frames';`] : []), `import manifest from ${JSON.stringify(MANIFEST_ID)};`, `import Document from ${JSON.stringify(documentSpec())};`, `import App from ${JSON.stringify(app)};`, ...(toolbar ? [`import { DevToolbar } from ${JSON.stringify(DEVTOOLS_PACKAGE)};`] : []), ...errorBoundaryImport(), ...(setupPath ? [`import setup from ${JSON.stringify(setupPath)};`] : []), ``, ...(setupPath ? [`if (typeof setup !== 'function') {`, `  throw new Error('[@solidjs/vite-plugin] start.setup must default-export a function ' +`, `    '((event, App) => Component | void | Promise<...>): ' + ${JSON.stringify(options.setup)});`, `}`, ``] : []), ...(serverComponents ? [
     // Direct (in-process) server-function calls made during document
     // SSR must resolve to inline-renderable components; the endpoint
     // response transform is installed separately by the
@@ -1518,7 +1535,7 @@ function startServe(options, internal = {}) {
     // the *complete* render) and buffers the stream — so it crosses
     // boxed under a private key the generated handler unboxes
     // (both modules are ours).
-    `export function render(request, context) {`, `  const prepared = setup(getRequestEvent(), App);`, `  if (prepared && typeof prepared.then === 'function') {`, `    return prepared.then((component) => ({ ${STREAM_BOX}: renderApp(component || App) }));`, `  }`, `  return renderApp(prepared || App);`, `}`, ``, `function renderApp(Root) {`, `  return renderToStream(() => (`, ...documentTree('Root'), `  ), ${streamOptions});`, `}`] : [`export function render(request, context) {`, `  return renderToStream(() => (`, ...documentTree('App'), `  ), ${streamOptions});`, `}`])].join('\n');
+    `export function render(request, context) {`, `  const prepared = setup(getRequestEvent(), App);`, `  if (prepared && typeof prepared.then === 'function') {`, `    return prepared.then((component) => ({ ${STREAM_BOX}: renderApp(component || App) }));`, `  }`, `  return renderApp(prepared || App);`, `}`, ``, `function renderApp(Root) {`, `  return renderToStream(() => (`, ...documentTree('Root', toolbar ? 'DevToolbar' : undefined), `  ), ${streamOptions});`, `}`] : [`export function render(request, context) {`, `  return renderToStream(() => (`, ...documentTree('App', toolbar ? 'DevToolbar' : undefined), `  ), ${streamOptions});`, `}`])].join('\n');
   }
   function generatedEntryClientCode(toolbar) {
     const {
@@ -1530,9 +1547,9 @@ function startServe(options, internal = {}) {
       // app cannot claim server DOM anyway. The entry script is injected
       // without `async` (plain module = deferred), so document.body is
       // complete when this runs.
-      return [`import { render } from '@solidjs/web';`, ...errorBoundaryImport(), ...(toolbar ? [`import { DevToolbar } from ${JSON.stringify(DEVTOOLS_ID)};`] : []), `import App from ${JSON.stringify(app)};`, ``, `render(() => ${isBuild && errorBoundary ? '<DefaultErrorBoundary><App /></DefaultErrorBoundary>' : toolbar ? '<DevToolbar><App /></DevToolbar>' : '<App />'}, document.body);`].join('\n');
+      return [`import { render } from '@solidjs/web';`, ...errorBoundaryImport(), ...(toolbar ? [`import { DevToolbar } from ${JSON.stringify(DEVTOOLS_PACKAGE)};`] : []), `import App from ${JSON.stringify(app)};`, ``, `render(() => ${isBuild && errorBoundary ? '<DefaultErrorBoundary><App /></DefaultErrorBoundary>' : toolbar ? '<DevToolbar><App /></DevToolbar>' : '<App />'}, document.body);`].join('\n');
     }
-    return [`import { hydrate } from '@solidjs/web';`, ...(toolbar ? [`import { DevToolbar } from ${JSON.stringify(DEVTOOLS_ID)};`] : []), ...(serverComponents ? [`import { installServerComponents } from '@solidjs/web/frames';`] : []), ...errorBoundaryImport(), `import Document from ${JSON.stringify(documentSpec())};`, `import App from ${JSON.stringify(app)};`, ``, ...(serverComponents ? [
+    return [`import { hydrate } from '@solidjs/web';`, ...(toolbar ? [`import { DevToolbar } from ${JSON.stringify(DEVTOOLS_PACKAGE)};`] : []), ...(serverComponents ? [`import { installServerComponents } from '@solidjs/web/frames';`] : []), ...errorBoundaryImport(), `import Document from ${JSON.stringify(documentSpec())};`, `import App from ${JSON.stringify(app)};`, ``, ...(serverComponents ? [
     // Installs the t=0 document-adoption registry and the transport
     // policy (component responses morph their boundary instead of
     // decoding as data). Must run before hydrate().
@@ -1713,9 +1730,9 @@ function startServe(options, internal = {}) {
     enforce: 'pre',
     config(userConfig, env) {
       root = path.resolve(userConfig.root || process.cwd());
-      devtools = env.command === 'serve' && !env.isPreview && options.devtools !== false ? undefined : false;
-      devtoolsResolution = undefined;
-      devtoolsId = null;
+      devtoolsEnabled = env.command === 'serve' && !env.isPreview && options.devtools !== false;
+      devtoolsResolutions = {};
+      devtoolsIds = {};
       entries = resolveEntries(root, options, clientMode);
       middlewarePath = options.middleware ? path.resolve(root, normalizeUserPath(root, options.middleware, 'middleware')) : null;
       // Server-mode only, like `entryServer`/`external` (a documented
@@ -1806,7 +1823,7 @@ function startServe(options, internal = {}) {
             }
           },
           // Presence of `builder` makes a plain `vite build` build the
-          // whole app (all environments: client then ssr) on Vite 6+.
+          // whole app (all environments: client then ssr).
           // A classic `vite build --ssr` invocation must stay a
           // single-environment build, so it doesn't get the flag.
           ...(env.isSsrBuild ? {} : {
@@ -1836,23 +1853,32 @@ function startServe(options, internal = {}) {
           optimizeDeps: {
             entries: scanEntries,
             // Like the refresh runtime in the main plugin: the toolbar
-            // graph is injected behind virtual modules the scanner never
-            // crawls, so pre-bundle it (and the server-functions runtime
-            // the virtual module pulls in) up front — first-request
-            // discovery would re-optimize and full-reload the page.
-            ...(devtools === undefined && devtoolsReachableFromRoot(root) ? {
-              include: [DEVTOOLS_PACKAGE, '@solidjs/web/server-functions']
-            } : {})
+            // graph is injected behind modules the scanner never crawls,
+            // so pre-bundle it and the server-functions runtime up front.
+            ...(() => {
+              const spec = devtoolsEnabled ? devtoolsIncludeSpec(root) : null;
+              return spec ? {
+                include: [spec, '@solidjs/web/server-functions']
+              } : {};
+            })()
           }
         })
       };
     },
+    configEnvironment(name, config) {
+      if (name !== 'ssr') return;
+      config.resolve ??= {};
+      const noExternal = config.resolve.noExternal;
+      if (noExternal !== true) {
+        config.resolve.noExternal = [...(Array.isArray(noExternal) ? noExternal : noExternal ? [noExternal] : []), DEVTOOLS_PACKAGE];
+      }
+    },
     configResolved(config) {
       root = config.root;
       base = config.base;
       isBuild = config.command === 'build';
     },
-    resolveId(source, importer) {
+    resolveId(source, importer, opts) {
       if (source === HANDLER_ID) {
         return {
           id: HANDLER_ID,
@@ -1871,18 +1897,16 @@ function startServe(options, internal = {}) {
           moduleSideEffects: source === ENTRY_CLIENT_ID
         };
       }
-      if (devtools && (source === DEVTOOLS_ID || source === DEVTOOLS_MOUNT_ID)) {
+      if (devtoolsEnabled && source === DEVTOOLS_MOUNT_ID) {
         return {
           id: source,
           moduleSideEffects: true
         };
       }
-      // The virtual devtools modules import the package by its bare name,
-      // but a virtual importer gives Vite no directory to walk, so the
-      // specifier would only resolve from the Vite root — which fails in
-      // pnpm-isolated apps where the package is not a root-level install.
-      // Delegate to the resolution captured at detection time instead.
-      if (devtoolsId && source === DEVTOOLS_PACKAGE && (importer === DEVTOOLS_ID || importer === DEVTOOLS_MOUNT_ID)) {
+      // Generated modules have no directory for bare-package resolution.
+      // Reuse the app-relative id captured during detection.
+      const devtoolsId = devtoolsIds[getEnvironmentConsumer(this.environment, opts)];
+      if (devtoolsId && source === DEVTOOLS_PACKAGE && (importer === ENTRY_SERVER_ID || importer === ENTRY_CLIENT_ID || importer === DEVTOOLS_MOUNT_ID)) {
         return {
           id: devtoolsId
         };
@@ -1904,37 +1928,40 @@ function startServe(options, internal = {}) {
         }
         return devStylesModuleCode(this.environment, file => this.addWatchFile(file));
       }
-      if (id === ENTRY_SERVER_ID) return generatedEntryServerCode();
+      if (id === ENTRY_SERVER_ID) {
+        const toolbar = clientMode ? false : await resolveDevtools((source, importer) => this.resolve(source, importer, {
+          skipSelf: true
+        }), requireEntries().app, 'server');
+        return generatedEntryServerCode(toolbar);
+      }
       if (id === ENTRY_CLIENT_ID) {
         const toolbar = await resolveDevtools((source, importer) => this.resolve(source, importer, {
           skipSelf: true
-        }), requireEntries().app);
+        }), requireEntries().app, 'client');
         return generatedEntryClientCode(toolbar);
       }
       if (id === DOCUMENT_ID) return documentShellCode;
       if (id === ERROR_BOUNDARY_ID) return errorBoundaryCode;
-      if (id === DEVTOOLS_ID || id === DEVTOOLS_MOUNT_ID) {
-        // A cold direct request (stale tab reload) can reach the virtual
-        // module before the entry has triggered detection — run it here so
-        // first-touch order doesn't matter.
-        if (!isBuild && consumer === 'client' && devtools === undefined) {
+      if (id === DEVTOOLS_MOUNT_ID) {
+        let enabled = false;
+        if (devtoolsEnabled && consumer === 'client') {
           const {
             app,
             entryClient
           } = requireEntries();
-          await resolveDevtools((source, importer) => this.resolve(source, importer, {
+          enabled = await resolveDevtools((source, importer) => this.resolve(source, importer, {
             skipSelf: true
-          }), app ?? path.resolve(root, entryClient));
+          }), app ?? path.resolve(root, entryClient), 'client');
         }
-        if (isBuild || !devtools || consumer !== 'client') {
+        if (!enabled) {
           this.error(`${id} is only available to the development client.`);
         }
-        return id === DEVTOOLS_ID ? devtoolsModuleCode() : devtoolsMountModuleCode();
+        return devtoolsMountModuleCode();
       }
       return null;
     },
     async transform(code, id, opts) {
-      if (isBuild || devtools === false) return null;
+      if (isBuild || !devtoolsEnabled) return null;
       const current = requireEntries();
       if (current.generated || getEnvironmentConsumer(this.environment, opts) !== 'client') {
         return null;
@@ -1946,7 +1973,7 @@ function startServe(options, internal = {}) {
       }
       const toolbar = await resolveDevtools((source, importer) => this.resolve(source, importer, {
         skipSelf: true
-      }), id);
+      }), id, 'client');
       if (!toolbar) return null;
       return {
         code: `import ${JSON.stringify(DEVTOOLS_MOUNT_ID)};\n${code}`,
@@ -2010,7 +2037,7 @@ function startServe(options, internal = {}) {
       // that gets the streamed SSR render.
       return () => {
         const ssrEnvironment = server.environments.ssr;
-        if (externalServer || ssrEnvironment && !isRunnableEnvironment(ssrEnvironment)) {
+        if (externalServer || !isRunnableEnvironment(ssrEnvironment)) {
           return;
         }
         server.middlewares.use((req, res, next) => {
@@ -2027,7 +2054,7 @@ function startServe(options, internal = {}) {
           (async () => {
             // Loaded through the SSR environment so the app, the request
             // event storage, and the handler share one module registry.
-            const handler = await server.ssrLoadModule(HANDLER_ID);
+            const handler = await ssrEnvironment.runner.import(HANDLER_ID);
             const styles = pageRequest ? await collectDevStyles(server, styleRoots(), styleFilter) : [];
             const devHead = styles.map(renderDevStyleTag).join('');
             // Post middlewares run after Vite's base middleware stripped
@@ -2052,7 +2079,6 @@ function startServe(options, internal = {}) {
             if (response.headers.has(DEV_FALLTHROUGH_HEADER)) return next();
             await sendWebResponse(res, response);
           })().catch(error => {
-            if (error instanceof Error) server.ssrFixStacktrace(error);
             // Vite's error middleware renders the overlay-enabled 500 page.
             next(error);
           });
@@ -2142,7 +2168,7 @@ function startServe(options, internal = {}) {
 // https://github.com/pyyupsk/vite-env), the design-correct prior art. The
 // implementation is fresh against this plugin's machinery: Standard Schema
 // is the only contract (no zod dependency or zod-specific paths), the
-// schema file loads through Vite's own `runnerImport`/`loadConfigFromFile`
+// schema file loads through Vite's own `runnerImport`
 // (no jiti), server-graph protection keys off the environment *consumer*
 // rather than environment-name lists, and the types are inferred from the
 // user's schema instead of introspected per-library.
@@ -2201,37 +2227,18 @@ function formatValidationError(issues, envFile, mode) {
   return `[@solidjs/vite-plugin] env validation failed (${issues.length} issue${issues.length === 1 ? '' : 's'}) — schema: ${envFile}, mode: ${mode}\n\n` + lines.join('\n') + `\n\nSet the variables in your environment or .env files, or adjust the schema.`;
 }
 
-/**
- * Loads the schema module at config time through Vite itself: `runnerImport`
- * (Vite 6.1+) evaluates TypeScript in-process with project resolution;
- * older Vite 6 falls back to `loadConfigFromFile`, the exact machinery that
- * loads vite.config.ts.
- */
+/** Loads the schema module through Vite with project resolution. */
 async function importSchemaModule(envFileAbs, root, mode) {
-  const vite = await import('vite');
-  if (typeof vite.runnerImport === 'function') {
-    const {
-      module,
-      dependencies
-    } = await vite.runnerImport(envFileAbs, {
-      root,
-      mode
-    });
-    return {
-      exported: module?.default,
-      dependencies: (dependencies || []).map(dep => path.resolve(root, dep)).filter(dep => existsSync(dep))
-    };
-  }
-  const result = await vite.loadConfigFromFile({
-    command: 'serve',
+  const {
+    module,
+    dependencies
+  } = await runnerImport(envFileAbs, {
+    root,
     mode
-  }, envFileAbs, root);
-  if (!result) {
-    throw new Error(`[@solidjs/vite-plugin] failed to load env schema from ${envFileAbs}`);
-  }
+  });
   return {
-    exported: result.config,
-    dependencies: (result.dependencies || []).map(dep => path.resolve(root, dep)).filter(dep => existsSync(dep))
+    exported: module?.default,
+    dependencies: dependencies.map(dep => path.resolve(root, dep)).filter(dep => existsSync(dep))
   };
 }
 function assertSchemaShape(exported, envFile, envPrefixes) {
@@ -2715,8 +2722,6 @@ const LAZY_PLACEHOLDER_PREFIX = '__SOLID_LAZY_MODULE__:';
  * solid-refresh#85 — is no longer used at all).
  */
 const REFRESH_RUNTIME_SOURCE = 'solid-js/refresh';
-const viteVersionMajor = +version.split('.')[0];
-const isVite8 = viteVersionMajor >= 8;
 const DEFAULT_STYLE_EXCLUDE = /node_modules/;
 const VIRTUAL_MANIFEST_ID = 'virtual:solid-manifest';
 const RESOLVED_VIRTUAL_MANIFEST_ID = '\0' + VIRTUAL_MANIFEST_ID;
@@ -3207,40 +3212,24 @@ function solidPlugin(options = {}) {
           // server-components runtime installs its response policy there).
           ...(command === 'serve' && serverComponents ? ['@solidjs/web/frames', '@solidjs/web/server-functions'] : []), ...solidPkgsConfig.optimizeDeps.include],
           exclude: solidPkgsConfig.optimizeDeps.exclude,
-          // Vite 8+ uses Rolldown for dependency scanning. Rolldown defaults to
-          // React's automatic JSX runtime for .tsx files, injecting a
-          // react/jsx-dev-runtime import that fails to resolve and aborts the
-          // scan. 'preserve' is no fix: the scanner re-parses the transformed
-          // output as plain JS, so any preserved JSX is a hard parse error
-          // (issue #262). The classic runtime is the only scan-safe lowering:
-          // it emits bare `React.createElement` calls without injecting any
-          // import, and the scan output is never executed — it only exists so
-          // rolldown can walk the import graph.
-          ...(isVite8 ? {
-            rolldownOptions: {
-              transform: {
-                jsx: {
-                  runtime: 'classic'
-                }
+          // Keep Solid TSX from injecting React's automatic runtime during scanning.
+          rolldownOptions: {
+            transform: {
+              jsx: {
+                runtime: 'classic'
               }
             }
-          } : {})
+          }
         },
         ...(Object.keys(test).length ? {
           test
         } : {})
       };
     },
-    // @ts-ignore This hook only works in Vite 6
-    async configEnvironment(name, config, opts) {
+    configEnvironment(name, config, opts) {
       config.resolve ??= {};
       // Emulate Vite default fallback for `resolve.conditions` if not set
       if (config.resolve.conditions == null) {
-        // @ts-ignore These exports only exist in Vite 6
-        const {
-          defaultClientConditions,
-          defaultServerConditions
-        } = await import('vite');
         if (config.consumer === 'client' || name === 'client' || opts.isSsrTargetWebworker) {
           config.resolve.conditions = [...defaultClientConditions];
         } else {
@@ -3575,8 +3564,7 @@ function solidPlugin(options = {}) {
   // would bake a manifest-less fallback into the server bundle. Every user
   // of such a setup had to hand-write this ordering plugin; absorb it.
   //
-  // Semantics (Vite 7.1+; Vite 6 has no plugin `buildApp` hook and ignores
-  // these, keeping its build-everything default):
+  // Semantics:
   // - The first hook builds the client environment first, but only where
   //   the ordering matters: a client build that emits a manifest and
   //   actually has an input. It runs at *normal* order, deliberately not