npm - @solidjs/vite-plugin - Versions diffs - 3.0.0-next.30 → 3.0.0-next.32 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.md +77 -10
package/dist/cjs/index.cjs +269 -119
package/dist/cjs/index.cjs.map +1 -1
package/dist/esm/index.mjs +269 -119
package/dist/esm/index.mjs.map +1 -1
package/dist/types/src/dev-manifest.d.ts +4 -3
package/dist/types/src/devtools/index.d.ts +3 -0
package/dist/types/src/environment.d.ts +5 -1
package/dist/types/src/ssr/index.d.ts +42 -1
package/package.json +13 -5

package/dist/esm/index.mjs CHANGED Viewed

@@ -6,8 +6,8 @@ import { mergeAndConcat } from 'merge-anything';
 import { createRequire } from 'module';
 import path from 'path';
 import { Readable } from 'node:stream';
-import { createFilter, loadEnv, version } from 'vite';
-import { pathToFileURL } from 'node:url';
+import { createFilter, normalizePath, loadEnv, runnerImport, defaultClientConditions, defaultServerConditions } from 'vite';
+import { pathToFileURL, fileURLToPath } from 'node:url';
 import { crawlFrameworkPkgs } from 'vitefu';
 // Node <-> web-standard request/response bridging shared by the plugin's dev
@@ -153,6 +153,7 @@ function joinBase(base, pathname) {
  * dynamically imported modules register their own styles when they render.
  */
+const defaultStyleFilter = id => !id.includes('node_modules');
 // The resolver is created plugin-side (it closes over the dev server) but is
 // called from the SSR module runner, which only shares `globalThis` with the
 // plugin when it runs in-process (the default). The primary channel is a
@@ -296,13 +297,15 @@ async function getModuleNode(env, file, importer) {
     return;
   }
 }
-async function collectModuleDeps(env, file, deps, crawled, onFile, importer) {
+async function collectModuleDeps(env, file, deps, crawled, filter, onFile, importer) {
   crawled.add(file);
   const node = await getModuleNode(env, file, importer);
   if (!node?.id || deps.has(node)) return;
   deps.add(node);
-  if (node.file && !node.id.includes('node_modules')) onFile?.(node.file);
-  if (cssFileRegExp.test(node.url.split('?')[0]) || node.id.includes('node_modules')) return;
+  const isCss = cssFileRegExp.test(node.url.split('?')[0]);
+  if (!isCss && node.file && !node.id.startsWith('\0') && !filter(node.file)) return;
+  if (node.file) onFile?.(node.file);
+  if (isCss) return;
   if (!node.transformResult) {
     await env.transformRequest(node.url).catch(() => {});
   }
@@ -313,7 +316,7 @@ async function collectModuleDeps(env, file, deps, crawled, onFile, importer) {
   // from dynamicDeps — dynamic imports load their own styles when rendered.
   for (const dep of directDeps) {
     if (crawled.has(dep)) continue;
-    await collectModuleDeps(env, dep, deps, crawled, onFile, node.id);
+    await collectModuleDeps(env, dep, deps, crawled, filter, onFile, node.id);
   }
 }
 function injectQuery(url, query) {
@@ -321,11 +324,11 @@ function injectQuery(url, query) {
 }
 /** Discovers ambient CSS in an entry graph without choosing how it is transported. */
-async function collectDevStyleSources(env, files, onFile) {
+async function collectDevStyleSources(env, files, onFile, filter = defaultStyleFilter) {
   const deps = new Set();
   const crawled = new Set();
   for (const file of files) {
-    await collectModuleDeps(env, file, deps, crawled, onFile);
+    await collectModuleDeps(env, file, deps, crawled, filter, onFile);
   }
   const css = [];
   const seen = new Set();
@@ -352,11 +355,11 @@ async function collectDevStyleSources(env, files, onFile) {
  * CSS into `<head>` so server-painted content is styled from the first byte
  * (no FOUC while waiting for Vite's client-side style injection).
  */
-async function collectDevStyles(server, files) {
+async function collectDevStyles(server, files, filter = defaultStyleFilter) {
   const ssrEnv = server.environments?.ssr;
   const clientEnv = server.environments?.client;
   if (!ssrEnv || !clientEnv) return [];
-  const sources = await collectDevStyleSources(ssrEnv, files.map(file => path.resolve(server.config.root, file)));
+  const sources = await collectDevStyleSources(ssrEnv, files.map(file => path.resolve(server.config.root, file)), undefined, filter);
   const css = [];
   for (const source of sources) {
     // `?direct` yields the compiled stylesheet text (what Vite serves for
@@ -412,7 +415,7 @@ function devModuleUrl(root, base, key) {
   // drive letter on Windows: /@fs/C:/…).
   return joinBase(base, '/@fs/' + absolute.replace(/^\//, '') + query);
 }
-function createDevAssetResolver(server) {
+function createDevAssetResolver(server, filter = defaultStyleFilter) {
   // Server-side lazy() re-requests a module's assets on every retry of a
   // suspended render pass (retries re-create the component). The build
   // manifest answers those repeats synchronously and the pass converges; an
@@ -446,7 +449,7 @@ function createDevAssetResolver(server) {
         // The module's dev URL doubles as its client entry: modulepreload
         // hint and hydration module-map value.
         const js = [devModuleUrl(root, base, key)];
-        const css = await collectDevStyles(server, [key]);
+        const css = await collectDevStyles(server, [key], filter);
         return {
           js,
           css
@@ -501,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;
       }
@@ -539,6 +542,11 @@ function boundaryModules() {
 function isRunnableEnvironment(environment) {
   return !!environment && typeof environment === 'object' && 'runner' in environment;
 }
+function getEnvironmentConsumer(environment, options) {
+  const consumer = environment?.config?.consumer;
+  if (consumer === 'client' || consumer === 'server') return consumer;
+  return options?.ssr ? 'server' : 'client';
+}
 // The `"use server"` directive compiler. This wraps the native
 // `transformDirectives` pass from @dom-expressions/compiler (Rust/Oxc); the
@@ -810,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);
@@ -975,12 +981,12 @@ function serverFunctions(options = {}, internal = {}) {
     const relative = path.relative(root, entry).split(path.sep).join('/');
     return relative.startsWith('..') ? '/@fs/' + entry : '/' + relative;
   }
-  const turnkeyPlugins = [{
+  const startPlugins = [{
     name: 'solid:server-functions/handler',
     enforce: 'pre',
     resolveId(source, _importer, opts) {
       if (source === HANDLER_ID$1) {
-        if (!opts?.ssr) {
+        if (getEnvironmentConsumer(this.environment, opts) !== 'server') {
           this.error(`${HANDLER_ID$1} is server-only; import it from your server entry (SSR build).`);
         }
         return {
@@ -991,7 +997,7 @@ function serverFunctions(options = {}, internal = {}) {
       return null;
     },
     load(id, opts) {
-      if (id === HANDLER_ID$1 && opts?.ssr) {
+      if (id === HANDLER_ID$1 && getEnvironmentConsumer(this.environment, opts) === 'server') {
         const externalDev = this.environment.mode === 'dev' && (internal.externalDevServer || !isRunnableEnvironment(this.environment));
         return handlerModuleCode(isBuild || externalDev);
       }
@@ -999,12 +1005,12 @@ function serverFunctions(options = {}, internal = {}) {
     }
   }];
   if (installDevMiddleware) {
-    turnkeyPlugins.push({
+    startPlugins.push({
       name: 'solid:server-functions/dev-middleware',
       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) => {
@@ -1027,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.
@@ -1035,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.
@@ -1047,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);
           });
         });
@@ -1111,7 +1116,7 @@ function serverFunctions(options = {}, internal = {}) {
       return null;
     },
     async load(id, opts) {
-      const mode = opts?.ssr ? 'server' : 'client';
+      const mode = getEnvironmentConsumer(this.environment, opts);
       if (id === manifestId) {
         if (isBuild && mode === 'server') {
           // Merge the client build's persisted discoveries at load time,
@@ -1134,7 +1139,7 @@ function serverFunctions(options = {}, internal = {}) {
     name: 'solid:server-functions/compiler',
     enforce: 'pre',
     async transform(code, fileId, opts) {
-      const mode = opts?.ssr ? 'server' : 'client';
+      const mode = getEnvironmentConsumer(this.environment, opts);
       const [id] = fileId.split('?');
       if (!filter(id)) {
         return null;
@@ -1167,7 +1172,13 @@ function serverFunctions(options = {}, internal = {}) {
       }
       return null;
     }
-  }, ...turnkeyPlugins];
+  }, ...startPlugins];
+}
+const DEVTOOLS_PACKAGE = '@solidjs/start-devtools';
+const DEVTOOLS_MOUNT_ID = 'virtual:solid-devtools/mount';
+function devtoolsMountModuleCode() {
+  return [`import { mountDevToolbar } from '${DEVTOOLS_PACKAGE}';`, `mountDevToolbar();`].join('\n');
 }
 // Start-mode serving for plain Vite apps: `solid({ start: {...} })` (or the
@@ -1184,7 +1195,7 @@ function serverFunctions(options = {}, internal = {}) {
 //   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
@@ -1252,6 +1263,7 @@ const RESOLVED_DEV_STYLES_ID = '\0' + DEV_STYLES_ID;
 const ENTRY_SERVER_ID = 'virtual:solid-ssr-entry-server.tsx';
 const ENTRY_CLIENT_ID = 'virtual:solid-ssr-entry-client.tsx';
 const DOCUMENT_ID = 'virtual:solid-ssr-document.tsx';
+const ERROR_BOUNDARY_ID = 'virtual:solid-ssr-error-boundary.tsx';
 const MANIFEST_ID = 'virtual:solid-manifest';
 const SERVER_FUNCTION_HANDLER_ID = 'virtual:solid-server-function-handler';
 const STORAGE_SOURCE = '@solidjs/web/storage';
@@ -1363,6 +1375,11 @@ function startServe(options, internal = {}) {
   // the server-function handler module either way). Everything is gated
   // codegen: with the option off, none of these imports exist anywhere.
   const serverComponents = !!internal.serverComponents;
+  const errorBoundary = options.errorBoundary !== false;
+  const styleFilter = internal.styleFilter;
+  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;
@@ -1379,6 +1396,65 @@ function startServe(options, internal = {}) {
     if (!entries) throw new Error('[@solidjs/vite-plugin] SSR entries not resolved yet');
     return entries;
   }
+  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 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 id !== null;
+  }
+  /**
+   * Cheap walk-up probe mirroring how the optimizer resolves bare
+   * `optimizeDeps.include` entries: is @solidjs/start-devtools reachable from
+   * 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.
+   */
+  function devtoolsReachableFrom(dir) {
+    for (let current = dir;;) {
+      if (existsSync(path.join(current, 'node_modules', DEVTOOLS_PACKAGE, 'package.json'))) {
+        return true;
+      }
+      const parent = path.dirname(current);
+      if (parent === current) return false;
+      current = parent;
+    }
+  }
+  /**
+   * 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() {
@@ -1418,7 +1494,7 @@ function startServe(options, internal = {}) {
     return generated ? [app, ...(document ? [document] : [])] : [path.resolve(root, entryServer)];
   }
   async function devStylesModuleCode(environment, watchFile) {
-    const styles = await collectDevStyleSources(environment, styleRoots(), watchFile);
+    const styles = await collectDevStyleSources(environment, styleRoots(), watchFile, styleFilter);
     if (!styles.length) return `export default '';`;
     const imports = styles.map((style, index) => {
       const specifier = style.url.includes('?') ? `${style.url}&inline` : `${style.url}?inline`;
@@ -1426,19 +1502,26 @@ function startServe(options, internal = {}) {
     });
     return [...imports, `const ids = ${JSON.stringify(styles.map(style => style.id))};`, `const css = [${styles.map((_, index) => `css${index}`).join(', ')}];`, `const escapeAttr = value => value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');`, `export default css.map((content, index) => {`, `  const id = escapeAttr(ids[index]);`, `  return '<style data-asset="' + id + '" data-vite-dev-id="' + id + '">' +`, `    content.replace(/<\\/(style)/gi, '<\\\\/$1') + '</style>';`, `}).join('');`].join('\n');
   }
-  function generatedEntryServerCode() {
+  function errorBoundaryImport() {
+    return isBuild && errorBoundary ? [`import { DefaultErrorBoundary } from ${JSON.stringify(ERROR_BOUNDARY_ID)};`] : [];
+  }
+  function documentTree(root, wrapper) {
+    const content = wrapper ? `<${wrapper}><${root} /></${wrapper}>` : `<${root} />`;
+    return isBuild && errorBoundary ? [`  <DefaultErrorBoundary>`, `    <Document>`, `      <DefaultErrorBoundary>`, `        ${content}`, `      </DefaultErrorBoundary>`, `    </Document>`, `  </DefaultErrorBoundary>`] : [`  <Document>`, `    ${content}`, `  </Document>`];
+  }
+  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)
       // and once at build time into dist/client/index.html. The client
       // entry script is injected by the handler, exactly like SSR mode.
-      return [`import { renderToStream } from '@solidjs/web';`, `import manifest from ${JSON.stringify(MANIFEST_ID)};`, `import Document from ${JSON.stringify(documentSpec())};`, ``, `export function render(request, context) {`, `  return renderToStream(() => <Document />, { manifest });`, `}`].join('\n');
+      return [`import { renderToStream } from '@solidjs/web';`, `import manifest from ${JSON.stringify(MANIFEST_ID)};`, `import Document from ${JSON.stringify(documentSpec())};`, ...errorBoundaryImport(), ``, `export function render(request, context) {`, `  return renderToStream(() => (`, ...(isBuild && errorBoundary ? [`  <DefaultErrorBoundary>`, `    <Document />`, `  </DefaultErrorBoundary>`] : [`  <Document />`]), `  ), { manifest });`, `}`].join('\n');
     }
     const {
       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)};`, ...(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
@@ -1452,9 +1535,9 @@ 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(() => (`, `    <Document>`, `      <Root />`, `    </Document>`, `  ), ${streamOptions});`, `}`] : [`export function render(request, context) {`, `  return renderToStream(() => (`, `    <Document>`, `      <App />`, `    </Document>`, `  ), ${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() {
+  function generatedEntryClientCode(toolbar) {
     const {
       app
     } = requireEntries();
@@ -1464,13 +1547,13 @@ 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';`, `import App from ${JSON.stringify(app)};`, ``, `render(() => <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';`, ...(serverComponents ? [`import { installServerComponents } from '@solidjs/web/frames';`] : []), `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().
-    `installServerComponents();`, ``] : []), `hydrate(() => (`, `  <Document>`, `    <App />`, `  </Document>`, `), document);`].join('\n');
+    `installServerComponents();`, ``] : []), `hydrate(() => (`, ...documentTree('App', toolbar ? 'DevToolbar' : undefined), `), document);`].join('\n');
   }
   // Built-in document shell: minimal, hydration-ready. The client entry
@@ -1481,6 +1564,7 @@ function startServe(options, internal = {}) {
   // HydrationScript is covered too: the handler strips the event-capture
   // script from the client-mode shell.)
   const documentShellCode = [...(clientMode ? [] : [`import { HydrationScript } from '@solidjs/web';`, ``]), `export default function Document(props) {`, `  return (`, `    <html lang="en">`, `      <head>`, `        <meta charset="utf-8" />`, `        <meta name="viewport" content="width=device-width, initial-scale=1.0" />`, ...(clientMode ? [] : [`        <HydrationScript />`]), `      </head>`, `      <body>{props.children}</body>`, `    </html>`, `  );`, `}`].join('\n');
+  const errorBoundaryCode = [`import { Errored } from 'solid-js';`, `import { httpStatus, isServer } from '@solidjs/web';`, ``, `function ErrorFallback(props) {`, `  console.error(props.error());`, `  httpStatus(500);`, `  return (`, `    <span style="font-size:1.5em;text-align:center;position:fixed;left:0;bottom:55%;width:100%">`, `      {isServer ? '500 | Internal Server Error' : 'Error | Uncaught Client Exception'}`, `    </span>`, `  );`, `}`, ``, `export function DefaultErrorBoundary(props) {`, `  return (`, `    <Errored fallback={(error) => <ErrorFallback error={error} />}>`, `      {props.children}`, `    </Errored>`, `  );`, `}`].join('\n');
   // The handler module: dev and prod share the render/response plumbing;
   // they differ in how the client entry URL is known (baked dev URL vs a
@@ -1532,7 +1616,7 @@ function startServe(options, internal = {}) {
     // head-open splice actively broke hydration — a script ahead of the
     // authored <head> elements claims as the first walked child and drifts
     // every positional claim after it.
-    lines.push(``, `function createHtmlChunkTransform(clientEntry, extraHead) {`, `  let first = true;`, `  let injected = false;`, `  return (chunk) => {`);
+    lines.push(``, `function escapeAttribute(value) {`, `  return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');`, `}`, ``, `function createHtmlChunkTransform(clientEntry, extraHead, nonce) {`, `  const nonceAttr = nonce ? ' nonce="' + escapeAttribute(nonce) + '"' : '';`, `  let first = true;`, `  let injected = false;`, `  return (chunk) => {`);
     if (!generated) {
       // Authored entries reference the client entry by its dev path (the
       // `<script src="/src/entry-client.tsx">` convention); rewrite it to
@@ -1562,7 +1646,7 @@ function startServe(options, internal = {}) {
       // scripts default to deferred execution, which is exactly right for a
       // fresh render-into-body mount (hydration, by contrast, wants to
       // start as early as possible).
-      headParts.push(`(clientEntry ? '<script type="module" src="' + clientEntry + '"${clientMode ? '' : ' async'}></' + 'script>' : '')`);
+      headParts.push(`(clientEntry ? '<script type="module"' + nonceAttr + ' src="' + clientEntry + '"${clientMode ? '' : ' async'}></' + 'script>' : '')`);
     }
     if (headParts.length) {
       lines.push(`      chunk = chunk.replace('</head>', ${headParts.join(' + ')} + '</head>');`);
@@ -1616,7 +1700,7 @@ function startServe(options, internal = {}) {
     // The runtime's response-head lifecycle: commit at shell flush,
     // pre-flush Location as a real redirect, post-flush Location as the
     // script fallback; the transform injects the doctype/head pieces.
-    `  return createSSRResponse(result, event, {`, `    responseInit: options.responseInit,`, `    nonce: options.nonce,`, `    transformChunk: createHtmlChunkTransform(clientEntry, options.devHead),`, `  });`, `}`, ``, `export async function handleRequest(request, options = {}) {`,
+    `  return createSSRResponse(result, event, {`, `    responseInit: options.responseInit,`, `    nonce: options.nonce,`, `    transformChunk: createHtmlChunkTransform(clientEntry, options.devHead, options.nonce),`, `  });`, `}`, ``, `export async function handleRequest(request, options = {}) {`,
     // `options.event` is the public wrapper->event extension seam: extra
     // fields (conventionally `nativeEvent`, the platform's raw request
     // object) spread over the event's defaults at creation, so hosts and
@@ -1646,6 +1730,9 @@ function startServe(options, internal = {}) {
     enforce: 'pre',
     config(userConfig, env) {
       root = path.resolve(userConfig.root || process.cwd());
+      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
@@ -1736,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 ? {} : {
@@ -1764,17 +1851,34 @@ function startServe(options, internal = {}) {
             }
           } : {}),
           optimizeDeps: {
-            entries: scanEntries
+            entries: scanEntries,
+            // Like the refresh runtime in the main plugin: the toolbar
+            // 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) {
+    resolveId(source, importer, opts) {
       if (source === HANDLER_ID) {
         return {
           id: HANDLER_ID,
@@ -1787,33 +1891,95 @@ function startServe(options, internal = {}) {
           moduleSideEffects: true
         };
       }
-      if (source === ENTRY_SERVER_ID || source === ENTRY_CLIENT_ID || source === DOCUMENT_ID) {
+      if (source === ENTRY_SERVER_ID || source === ENTRY_CLIENT_ID || source === DOCUMENT_ID || source === ERROR_BOUNDARY_ID) {
         return {
           id: source,
           moduleSideEffects: source === ENTRY_CLIENT_ID
         };
       }
+      if (devtoolsEnabled && source === DEVTOOLS_MOUNT_ID) {
+        return {
+          id: source,
+          moduleSideEffects: true
+        };
+      }
+      // 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
+        };
+      }
       return null;
     },
     async load(id, opts) {
+      const consumer = getEnvironmentConsumer(this.environment, opts);
       if (id === HANDLER_ID) {
-        if (!opts?.ssr) {
+        if (consumer !== 'server') {
           this.error(`${HANDLER_ID} is server-only; import it from server code (SSR build).`);
         }
         const externalDev = !isBuild && this.environment.mode === 'dev' && (externalServer || !isRunnableEnvironment(this.environment));
         return handlerModuleCode(externalDev);
       }
       if (id === RESOLVED_DEV_STYLES_ID) {
-        if (!opts?.ssr || this.environment.mode !== 'dev') {
+        if (consumer !== 'server' || this.environment.mode !== 'dev') {
           this.error(`${DEV_STYLES_ID} is only available to the development server handler.`);
         }
         return devStylesModuleCode(this.environment, file => this.addWatchFile(file));
       }
-      if (id === ENTRY_SERVER_ID) return generatedEntryServerCode();
-      if (id === ENTRY_CLIENT_ID) return generatedEntryClientCode();
+      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, 'client');
+        return generatedEntryClientCode(toolbar);
+      }
       if (id === DOCUMENT_ID) return documentShellCode;
+      if (id === ERROR_BOUNDARY_ID) return errorBoundaryCode;
+      if (id === DEVTOOLS_MOUNT_ID) {
+        let enabled = false;
+        if (devtoolsEnabled && consumer === 'client') {
+          const {
+            app,
+            entryClient
+          } = requireEntries();
+          enabled = await resolveDevtools((source, importer) => this.resolve(source, importer, {
+            skipSelf: true
+          }), app ?? path.resolve(root, entryClient), 'client');
+        }
+        if (!enabled) {
+          this.error(`${id} is only available to the development client.`);
+        }
+        return devtoolsMountModuleCode();
+      }
       return null;
     },
+    async transform(code, id, opts) {
+      if (isBuild || !devtoolsEnabled) return null;
+      const current = requireEntries();
+      if (current.generated || getEnvironmentConsumer(this.environment, opts) !== 'client') {
+        return null;
+      }
+      // Module ids are always forward-slashed; normalize the path.resolve
+      // side too so the comparison holds on Windows.
+      if (normalizePath(id.split('?')[0]) !== normalizePath(path.resolve(root, current.entryClient))) {
+        return null;
+      }
+      const toolbar = await resolveDevtools((source, importer) => this.resolve(source, importer, {
+        skipSelf: true
+      }), id, 'client');
+      if (!toolbar) return null;
+      return {
+        code: `import ${JSON.stringify(DEVTOOLS_MOUNT_ID)};\n${code}`,
+        map: null
+      };
+    },
     configurePreviewServer(server) {
       // `vite build && vite preview` runs the production artifact as-is:
       // Vite's preview statics serve dist/client (see the config hook) and
@@ -1871,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) => {
@@ -1888,8 +2054,8 @@ 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 styles = pageRequest ? await collectDevStyles(server, styleRoots()) : [];
+            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
             // the configured `base` from req.url; restore it so the app
@@ -1913,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);
           });
@@ -2003,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.
@@ -2062,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) {
@@ -2576,8 +2722,7 @@ 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;
@@ -2832,10 +2977,30 @@ function solidPlugin(options = {}) {
   // `start: true` is sugar for the empty options bag — one start mode,
   // two spellings — so normalize here and let everything downstream see a
   // single shape (`false` behaves exactly like omission).
-  const turnkey = options.start === true ? {} : options.start || null;
+  const startOptions = options.start === true ? {} : options.start || null;
+  const styleFilterOptions = startOptions?.css?.filter;
+  // The CSS crawl walks the module graph from the app's own entries, so a
+  // plain createFilter allowlist can't express the option's purpose (opting
+  // node_modules graphs in): a bare `include` would reject the app sources
+  // the crawl has to traverse to ever reach the included package. Instead
+  // `include` rescues files on top of the baseline (everything except
+  // `exclude`, which defaults to node_modules), while a file matching both
+  // patterns stays excluded — createFilter's own conflict rule.
+  const createStyleFilter = resolve => {
+    const opts = resolve === undefined ? undefined : {
+      resolve
+    };
+    const base = createFilter(undefined, styleFilterOptions?.exclude ?? DEFAULT_STYLE_EXCLUDE, opts);
+    const include = styleFilterOptions?.include;
+    const hasInclude = include != null && (!Array.isArray(include) || include.length > 0);
+    const included = hasInclude ? createFilter(include, styleFilterOptions?.exclude, opts) : null;
+    return id => base(id) || (included ? included(id) : false);
+  };
+  let styleFilter = createStyleFilter();
+  const filterDevStyles = id => styleFilter(id);
   // `start.external` only means something when a server side exists to hand
   // over (SSR start mode); in client mode it is a documented no-op.
-  const externalDevServer = !!options.ssr && !!turnkey?.external;
+  const externalDevServer = !!options.ssr && !!startOptions?.external;
   let needHmr = false;
   let replaceDev = false;
   // The live dev server, kept so the dev manifest module can bake the bridge
@@ -3047,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 {
@@ -3113,6 +3262,7 @@ function solidPlugin(options = {}) {
       filter = createFilter(options.include, options.exclude, {
         resolve: projectRoot
       });
+      styleFilter = createStyleFilter(projectRoot);
       if (serverComponents && !(options.start && options.ssr)) {
         config.logger.warn('[@solidjs/vite-plugin] serverFunctions.components is set without SSR start mode (the `start` ' + 'option with `ssr: true`), so the plugin only installs the endpoint response transform ' + '(server functions returning components stream correctly). The document wiring — render ' + 'plugin, bootstrap script, and the client-side installServerComponents() call — is ' + "emitted by SSR start mode's generated entries; without it, server components only mount " + 'from post-boot streams and your client code must call installServerComponents() itself.');
       }
@@ -3126,7 +3276,7 @@ function solidPlugin(options = {}) {
       // that don't share globals with this process, through the HTTP bridge
       // endpoint the middleware serves.
       if (options.ssr || options.start) {
-        registerDevAssetResolver(server.config.root, createDevAssetResolver(server));
+        registerDevAssetResolver(server.config.root, createDevAssetResolver(server, filterDevStyles));
         installDevManifestBridge(server);
       }
       if (!needHmr) return;
@@ -3242,7 +3392,7 @@ function solidPlugin(options = {}) {
       }
     },
     async transform(source, id, transformOptions) {
-      const isSsr = transformOptions && transformOptions.ssr;
+      const isSsr = getEnvironmentConsumer(this.environment, transformOptions) === 'server';
       const currentFileExtension = getExtension(id);
       const extensionsToWatch = options.extensions || [];
       const allExtensions = extensionsToWatch.map(extension =>
@@ -3382,7 +3532,7 @@ function solidPlugin(options = {}) {
     // With start mode on (either variant), the dev middleware dispatches
     // the endpoint through the SSR handler so user middleware and the
     // stub-backed request event front it exactly like page SSR.
-    ...(turnkey ? {
+    ...(startOptions ? {
       ssrHandler: SSR_HANDLER_ID
     } : {})
   }), mainPlugin] : [boundaryModules(), mainPlugin];
@@ -3390,15 +3540,16 @@ function solidPlugin(options = {}) {
   // The `start` option opts into start-mode serving on top of the transforms;
   // the `ssr` boolean picks the mode (a bare `ssr: true` keeps the
   // historical transform-only behavior).
-  if (turnkey) {
+  if (startOptions) {
     plugins.push(
     // Typed env (`start.env`) rides both start modes: config-time
     // validation, the virtual:env/{server,client} modules, generated
     // types, and the client-bundle leak scan.
-    ...startEnv(turnkey.env), ...startServe(turnkey, {
+    ...startEnv(startOptions.env), ...startServe(startOptions, {
       serverFunctions: !!options.serverFunctions,
       serverComponents,
-      ssr: !!options.ssr
+      ssr: !!options.ssr,
+      styleFilter: filterDevStyles
     }));
   }
@@ -3413,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