@solidjs/vite-plugin 3.0.0-next.27

package/dist/cjs/index.cjs

@@ -0,0 +1,3412 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var babel = require('@babel/core');
+var remapping = require('@ampproject/remapping');
+var solid = require('babel-preset-solid');
+var fs = require('fs');
+var mergeAnything = require('merge-anything');
+var module$1 = require('module');
+var path = require('path');
+var node_stream = require('node:stream');
+var vite = require('vite');
+var node_url = require('node:url');
+var vitefu = require('vitefu');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var babel__namespace = /*#__PURE__*/_interopNamespaceDefault(babel);
+
+// Node <-> web-standard request/response bridging shared by the plugin's dev
+// middlewares (server functions and SSR). The virtual production handlers
+// speak web Request/Response only; this is the node:http glue the dev server
+// needs to talk to them.
+
+
+/**
+ * `urlPath` overrides `req.url` when the middleware needs to dispatch a
+ * different URL than the one node saw — the dev middlewares use it to
+ * restore the configured Vite `base` that the dev/preview base middleware
+ * stripped, so the handler always sees production-shaped URLs.
+ */
+function webRequestFromNode(req, urlPath) {
+  const url = new URL(urlPath ?? req.url ?? '/', `http://${req.headers.host || 'localhost'}`);
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === undefined) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) headers.append(key, item);
+    } else {
+      headers.append(key, value);
+    }
+  }
+  const method = req.method || 'GET';
+  const body = method === 'GET' || method === 'HEAD' ? undefined : node_stream.Readable.toWeb(req);
+  return new Request(url, {
+    method,
+    headers,
+    body,
+    // undici requires half-duplex for streamed request bodies.
+    ...(body ? {
+      duplex: 'half'
+    } : {})
+  });
+}
+async function sendWebResponse(res, response) {
+  res.statusCode = response.status;
+  // set-cookie is the one header that must not be comma-joined.
+  const cookies = response.headers.getSetCookie?.();
+  response.headers.forEach((value, key) => {
+    if (key !== 'set-cookie') res.setHeader(key, value);
+  });
+  if (cookies && cookies.length) res.setHeader('set-cookie', cookies);
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  res.on('close', () => {
+    reader.cancel().catch(() => {});
+  });
+  try {
+    while (true) {
+      const {
+        done,
+        value
+      } = await reader.read();
+      if (done) break;
+      // A response whose client already went away never emits 'drain'
+      // (writes are no-ops), so a backpressure wait must also settle on
+      // 'close'/'error' or an aborted streaming response parks this promise
+      // — and the reader and Response it holds — forever.
+      if (res.destroyed) return;
+      if (!res.write(value)) {
+        const drained = await new Promise(resolve => {
+          const settle = ok => {
+            res.off('drain', onDrain);
+            res.off('close', onGone);
+            res.off('error', onGone);
+            resolve(ok);
+          };
+          const onDrain = () => settle(true);
+          const onGone = () => settle(false);
+          res.once('drain', onDrain);
+          res.once('close', onGone);
+          res.once('error', onGone);
+        });
+        // Client gone mid-stream; the 'close' handler cancels the reader.
+        if (!drained) return;
+      }
+    }
+    res.end();
+  } catch {
+    res.destroy();
+  }
+}
+function joinBase(base, pathname) {
+  // Absolute-URL or relative bases (CDN deploys, './') don't prefix
+  // same-origin server paths.
+  if (!base.startsWith('/')) return pathname;
+  return (base.endsWith('/') ? base.slice(0, -1) : base) + pathname;
+}
+
+/**
+ * Dev-mode asset resolution: the `virtual:solid-manifest` module exports a
+ * resolver function in dev (instead of the static object a build produces),
+ * and the runtime installs it as `context.resolveAssets` verbatim. When
+ * server-side `lazy()` resolves a module key, the resolver walks the SSR
+ * environment's live module graph collecting transitively imported CSS and
+ * answers with inline-style descriptors — SSR'd `<style data-vite-dev-id>`
+ * tags that Vite's HMR client adopts on startup, so dev CSS is styled from
+ * the first streamed byte without fighting Vite's own style injection.
+ *
+ * The walk design follows SolidStart's collect-styles (by @katywings): crawl
+ * `transformResult.deps` on the SSR environment (the client environment's
+ * transform results don't list CSS deps), skipping dynamic imports since
+ * dynamically imported modules register their own styles when they render.
+ */
+
+// 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
+// `Symbol.for`-keyed registry mapping project roots to resolvers; isolated
+// runners (nitro's dev worker, workerd) won't find it and instead fall back
+// to fetching the HTTP bridge endpoint below.
+const DEV_MANIFEST_REGISTRY_KEY = '@solidjs/vite-plugin:dev-manifest';
+function registerDevAssetResolver(root, resolver) {
+  const key = Symbol.for(DEV_MANIFEST_REGISTRY_KEY);
+  const registry = globalThis[key] ??= {};
+  registry[root] = resolver;
+}
+
+/**
+ * HTTP bridge endpoint for isolated SSR runners. Hosts that evaluate server
+ * modules outside the Vite process (nitro's dev worker, workerd via
+ * @cloudflare/vite-plugin) can't see the `globalThis` registry, so the dev
+ * server itself serves asset resolution: `GET
+ * /@solidjs/vite-plugin/dev-manifest?key=<module key>` answers with the
+ * resolver's `ResolvedAssets` JSON (`null` when the key can't be resolved).
+ * The dev flavor of `virtual:solid-manifest` falls back to fetching it when
+ * the registry has no entry for the root — in-process consumers hit the
+ * registry and never touch HTTP.
+ */
+const DEV_MANIFEST_ENDPOINT = '/@solidjs/vite-plugin/dev-manifest';
+function installDevManifestBridge(server) {
+  // configureServer middlewares run ahead of Vite's internals, so `req.url`
+  // may or may not still carry the configured `base` — accept both forms.
+  const base = (server.config.base || '/').replace(/\/$/, '');
+  const basedEndpoint = base + DEV_MANIFEST_ENDPOINT;
+  server.middlewares.use(async (req, res, next) => {
+    const url = new URL(req.url || '/', 'http://localhost');
+    if (url.pathname !== DEV_MANIFEST_ENDPOINT && url.pathname !== basedEndpoint) return next();
+    const key = url.searchParams.get('key');
+    if (!key) {
+      res.statusCode = 400;
+      return res.end('Missing asset key');
+    }
+    try {
+      const registry = globalThis[Symbol.for(DEV_MANIFEST_REGISTRY_KEY)];
+      const resolver = registry?.[server.config.root];
+      if (!resolver) {
+        // A silent null strips the module's client assets from the SSR'd
+        // hydration asset map and hydration fails much later with a cryptic
+        // client-side error — report the miss where it happens.
+        console.error(`[@solidjs/vite-plugin] The dev manifest registry has no resolver for root "${server.config.root}" ` + `(requested asset key "${key}"). The module's client assets cannot be resolved and hydration ` + 'will fail for it. Typical causes: the dev server was not restarted after dependency changes, ' + 'or the install is stale.');
+      }
+      const assets = resolver ? await resolver.resolve(key) : null;
+      if (resolver && assets == null) {
+        console.error(`[@solidjs/vite-plugin] Dev manifest resolver returned no assets for key "${key}" (root "${server.config.root}"). ` + "The module's hydration preload entry will be missing.");
+      }
+      res.setHeader('content-type', 'application/json');
+      res.setHeader('cache-control', 'no-store');
+      return res.end(JSON.stringify(assets));
+    } catch (error) {
+      return next(error);
+    }
+  });
+}
+
+/**
+ * The absolute URL isolated runners should fetch the bridge from, baked into
+ * the dev flavor of `virtual:solid-manifest` when its code is generated.
+ * Generation happens while serving an SSR request, so the server is already
+ * listening and `resolvedUrls` carries the real origin (a config-time define
+ * could only guess the port). Middleware-mode servers have no origin of
+ * their own to advertise — returns null there, and the manifest module keeps
+ * the js-only fallback (in-process registry hits are unaffected either way).
+ */
+function devManifestBridgeUrl(server) {
+  const local = server.resolvedUrls?.local?.[0];
+  let origin = null;
+  if (local) {
+    origin = new URL(local).origin;
+  } else if (!server.config.server.middlewareMode) {
+    const address = server.httpServer?.address();
+    if (address && typeof address === 'object') {
+      const https = !!server.config.server.https;
+      origin = `${https ? 'https' : 'http'}://localhost:${address.port}`;
+    }
+  }
+  if (!origin) return null;
+  const base = (server.config.base || '/').replace(/\/$/, '');
+  return origin + base + DEV_MANIFEST_ENDPOINT;
+}
+
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/constants.ts
+const cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)$/;
+// Queried css imports (?url, ?inline, ?raw) are not ambient styles — the
+// importer controls them — so they must not be SSR'd as style tags.
+const nonAmbientQueryRegExp = /[?&](url|inline|raw)\b/;
+const NULL_BYTE_PLACEHOLDER = '/@id/__x00__';
+
+// Per Vite's convention virtual module ids are prefixed with `\0`, which
+// cannot appear in an HTML attribute (the parser replaces it). Serialize the
+// same placeholder form Vite's own URLs use. Adoption of virtual-module
+// styles additionally needs `devStylePatch` (below) to run client-side;
+// fs-backed CSS (the overwhelmingly common case) adopts without it.
+function wrapId(id) {
+  return id.replace(/^\0/, NULL_BYTE_PLACEHOLDER);
+}
+
+/**
+ * Inline dev script reconciling SSR'd style tags with Vite's HMR client.
+ * Frameworks that server-render whole documents should inline this in dev,
+ * in `<head>` before any module script. It does two things, via a
+ * MutationObserver so styles appended by streamed boundaries are handled as
+ * they arrive (Vite's client seeds its stylesheet registry from the DOM only
+ * once, when its module evaluates):
+ *
+ * - Rewrites serialized virtual-module ids (`/@id/__x00__…`) back to Vite's
+ *   null-byte form so seeding matches (a raw `\0` can't survive HTML).
+ * - Dedupes twins: a style tag that streams in after Vite's client has
+ *   seeded is missed by the scan, so the CSS module injects its own copy
+ *   client-side. Whenever two style tags share a `data-vite-dev-id`, the
+ *   SSR'd one (marked `data-asset`) is removed in favor of the Vite-owned
+ *   one, which is the tag HMR updates.
+ *
+ * Observation is two-phase to stay cheap: a document-wide subtree observer
+ * only for the streaming window (SSR tags can only arrive while the parser
+ * is consuming the stream; DOMContentLoaded marks its end), then a
+ * childList-only observer on `document.head` for the page lifetime — Vite
+ * injects twins into the head during hydration, which continues past
+ * DOMContentLoaded, and a non-subtree head observer never fires on app DOM
+ * churn, only on head insertions.
+ *
+ * Descends from SolidStart's PatchVirtualDevStyles (by @katywings); this
+ * belongs in Vite itself eventually.
+ */
+const devStylePatch = `(function(){var P=${JSON.stringify(NULL_BYTE_PLACEHOLDER)};var handle=function(el){var v=el.getAttribute("data-vite-dev-id");if(!v)return;if(v.indexOf(P)===0){v="\\0"+v.slice(P.length);el.setAttribute("data-vite-dev-id",v)}var all=document.querySelectorAll("style[data-vite-dev-id]");for(var i=0;i<all.length;i++){var o=all[i];if(o!==el&&o.getAttribute("data-vite-dev-id")===v){var ssr=o.hasAttribute("data-asset")?o:el.hasAttribute("data-asset")?el:null;if(ssr)ssr.remove();break}}};var scan=function(n){if(n.nodeType!==1)return;if(n.tagName==="STYLE")handle(n);else if(n.querySelectorAll)n.querySelectorAll("style[data-vite-dev-id]").forEach(handle)};var onMuts=function(muts){for(var i=0;i<muts.length;i++)muts[i].addedNodes.forEach(scan)};var headPhase=function(){scan(document.documentElement);new MutationObserver(onMuts).observe(document.head,{childList:true})};scan(document.documentElement);if(document.readyState==="loading"){var mo=new MutationObserver(onMuts);mo.observe(document.documentElement,{childList:true,subtree:true});document.addEventListener("DOMContentLoaded",function(){mo.disconnect();headPhase()})}else headPhase()})();`;
+async function getModuleNode(env, file, importer) {
+  try {
+    // fetchModule resolves through the plugin container with importer
+    // context, so dep strings that are placeholder-wrapped virtual URLs
+    // (`/@id/__x00__…`) or importer-relative specifiers land on the right
+    // module id — a raw moduleGraph/transformRequest lookup would miss them.
+    const resolved = await env.fetchModule(file, importer);
+    if (!('id' in resolved)) return;
+    return env.moduleGraph.getModuleById(resolved.id);
+  } catch {
+    return;
+  }
+}
+async function collectModuleDeps(env, file, deps, crawled, 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;
+  if (!node.transformResult) {
+    await env.transformRequest(node.url).catch(() => {});
+  }
+  const directDeps = node.transformResult?.deps;
+  if (!directDeps) return;
+
+  // transformResult.deps (unlike importedModules) separates static imports
+  // 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);
+  }
+}
+function injectQuery(url, query) {
+  return url.includes('?') ? `${url}&${query}` : `${url}?${query}`;
+}
+
+/** Discovers ambient CSS in an entry graph without choosing how it is transported. */
+async function collectDevStyleSources(env, files, onFile) {
+  const deps = new Set();
+  const crawled = new Set();
+  for (const file of files) {
+    await collectModuleDeps(env, file, deps, crawled, onFile);
+  }
+  const css = [];
+  const seen = new Set();
+  for (const node of deps) {
+    if (!node.id) continue;
+    const cleanUrl = node.url.split('?')[0];
+    if (!cssFileRegExp.test(cleanUrl) || nonAmbientQueryRegExp.test(node.url)) continue;
+    const id = wrapId(node.id);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    css.push({
+      id,
+      url: node.url
+    });
+  }
+  return css;
+}
+
+/**
+ * Walks the SSR module graph from `files` (root-relative or absolute) and
+ * returns inline-style descriptors for every transitively imported CSS
+ * module — the same shape the dev asset resolver answers with for lazy
+ * modules. Used by SSR start mode's dev middleware to inline the root entry's
+ * 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) {
+  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 css = [];
+  for (const source of sources) {
+    // `?direct` yields the compiled stylesheet text (what Vite serves for
+    // <link> requests) — through the client environment, whose css
+    // pipeline matches what the browser will run for HMR updates.
+    const result = await clientEnv.transformRequest(injectQuery(source.url, 'direct')).catch(() => null);
+    if (result?.code == null) continue;
+    css.push({
+      id: source.id,
+      content: result.code,
+      attrs: {
+        'data-vite-dev-id': source.id
+      }
+    });
+  }
+  return css;
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+}
+
+/**
+ * Serializes a dev style descriptor to the exact tag shape the SSR runtime
+ * emits for lazy-registered assets (`data-asset` marks the SSR'd copy so
+ * `devStylePatch` knows which twin to drop when Vite's client injects its
+ * own), so the dedup story is identical for entry styles and lazy styles.
+ */
+function renderDevStyleTag(desc) {
+  let attrs = '';
+  for (const name in desc.attrs) {
+    attrs += ` ${name}="${escapeAttr(String(desc.attrs[name]))}"`;
+  }
+  const content = desc.content.replace(/<\/(style)/gi, '<\\/$1');
+  return `<style data-asset="${escapeAttr(desc.id)}"${attrs}>${content}</style>`;
+}
+
+/**
+ * Browser URL for a lazy module's dev asset key (a project-root-relative
+ * path, query included when the module identity carries one). Vite only
+ * serves module URLs under the configured `base`, so it is always applied;
+ * root-external keys (`../…`, e.g. sibling workspace packages) can't be
+ * expressed as root-relative URLs at all — they get Vite's `/@fs/` form on
+ * the resolved absolute path instead. Mirrored by the generated fallback in
+ * `devManifestCode` (src/index.ts) — keep the two in sync.
+ */
+function devModuleUrl(root, base, key) {
+  const queryIndex = key.indexOf('?');
+  const file = queryIndex === -1 ? key : key.slice(0, queryIndex);
+  const query = queryIndex === -1 ? '' : key.slice(queryIndex);
+  if (!file.startsWith('..')) return joinBase(base, '/' + key);
+  const absolute = path.resolve(root, file).split(path.sep).join('/');
+  // Vite's fs URLs collapse the leading slash: /@fs/Users/… (and keep the
+  // drive letter on Windows: /@fs/C:/…).
+  return joinBase(base, '/@fs/' + absolute.replace(/^\//, '') + query);
+}
+function createDevAssetResolver(server) {
+  // 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
+  // always-async resolver instead suspends every retry on a brand-new
+  // promise, so a pass whose retry path re-creates the lazy component (a
+  // nested route's outlet does) loops forever — each cycle nests one resume
+  // closure until the render stack overflows and the escaped rejection kills
+  // the dev server. So: dedupe in-flight walks per key and answer
+  // synchronously once a key's assets are known. Any watcher event drops the
+  // cache — the next request re-walks the updated module graph, keeping dev
+  // CSS fresh.
+  const resolved = new Map();
+  const pending = new Map();
+  const {
+    root,
+    base
+  } = server.config;
+  let generation = 0;
+  server.watcher.on('all', () => {
+    generation++;
+    resolved.clear();
+    pending.clear();
+  });
+  const resolve = function resolveDevAssets(key) {
+    const cached = resolved.get(key);
+    if (cached) return cached;
+    let walk = pending.get(key);
+    if (!walk) {
+      const startedAt = generation;
+      walk = (async () => {
+        // 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]);
+        return {
+          js,
+          css
+        };
+      })().then(assets => {
+        if (generation === startedAt) {
+          resolved.set(key, assets);
+          pending.delete(key);
+        }
+        return assets;
+      }, error => {
+        if (generation === startedAt) pending.delete(key);
+        throw error;
+      });
+      pending.set(key, walk);
+    }
+    return walk;
+  };
+  return {
+    resolve,
+    resolveSync: key => resolved.get(key) ?? {
+      js: [devModuleUrl(root, base, key)],
+      css: []
+    }
+  };
+}
+
+const VIRTUAL_ID = '\0@solidjs/vite-plugin:boundary-modules';
+
+/**
+ * `server-only` and `client-only` marker modules: importing `server-only`
+ * from a module bundled for the client fails the build at resolve time with
+ * a descriptive error (and vice versa for `client-only`); in the allowed
+ * environment the marker resolves to an empty module.
+ *
+ * Server-only code pulled into a client bundle otherwise ships silently and
+ * crashes at runtime (in hydrating apps, typically as a cryptic hydration
+ * failure far from the real cause) — the marker turns that into a build
+ * error naming the importer.
+ *
+ * Always on (`enforce: 'pre'`), so the bare specifiers are claimed by this
+ * plugin even when React's `server-only`/`client-only` npm packages are
+ * installed — the environment semantics are the same, and claiming them
+ * keeps the behavior deterministic and the errors identifiable as ours.
+ */
+function boundaryModules() {
+  return {
+    name: 'solid:boundary-modules',
+    enforce: 'pre',
+    resolveId(id, importer, options) {
+      // The dep scanner (`vite:dep-scan`) crawls the client entries' RAW
+      // 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
+      // 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;
+      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).`);
+      } 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).`);
+      } else {
+        return null;
+      }
+      return VIRTUAL_ID;
+    },
+    load(id) {
+      if (id === VIRTUAL_ID) return 'export {}';
+    }
+  };
+}
+
+/**
+ * Cross-instance-safe stand-in for vite's `isRunnableDevEnvironment`.
+ *
+ * Vite's helper is an `instanceof RunnableDevEnvironment` check against the
+ * class of whichever `vite` module the CALLER imported. When this plugin is
+ * consumed through a workspace/`link:` install, its own `vite` import can
+ * resolve to a different physical copy than the one running the dev server —
+ * and then the `instanceof` is false for every environment, silently standing
+ * the SSR/dev middlewares down. The `runner` accessor is the type's defining
+ * member (`RunnableDevEnvironment` is exactly "a DevEnvironment with a
+ * runner"), so presence-check it instead of trusting class identity.
+ */
+function isRunnableEnvironment(environment) {
+  return !!environment && typeof environment === 'object' && 'runner' in environment;
+}
+
+// The `"use server"` directive compiler. This wraps the native
+// `transformDirectives` pass from @dom-expressions/compiler (Rust/Oxc); the
+// original Babel implementation (hoisted from solid-start) lived in this
+// directory through vite-plugin-solid@c052963e and remains the frozen
+// reference for the native pass's fixture suite in dom-expressions.
+
+let compilerPromise;
+
+// Loaded lazily so importing the plugin never pays for the native binding —
+// only setups that enable server functions load it (mirrors the JSX
+// compiler's opt-in loader in index.ts).
+async function loadCompiler() {
+  try {
+    return await (compilerPromise ??= import('@dom-expressions/compiler'));
+  } catch (error) {
+    compilerPromise = undefined;
+    const reason = error instanceof Error ? `\n\nCause: ${error.message}` : '';
+    throw new Error('@solidjs/vite-plugin: failed to load @dom-expressions/compiler (the "use server" ' + 'transform). Your platform should get a prebuilt native binary or the ' + '@dom-expressions/compiler-wasm32-wasi fallback — check that optional ' + 'dependencies were installed.' + reason);
+  }
+}
+
+/**
+ * Runs the directive transform over one module. Function IDs are
+ * `hash(relative path)-<counter>`, so the client and server builds of the
+ * same checkout agree on every ID (the wire contract) without baking
+ * machine-specific absolute paths into the output. A `valid: false` result
+ * means the module contained no matching directive and must be left
+ * untransformed. Invalid closure captures (a server function referencing a
+ * non-top-level binding) throw with the variable name and location.
+ */
+async function compile(id, code, options) {
+  const {
+    transformDirectives
+  } = await loadCompiler();
+  const result = transformDirectives(code, {
+    filename: id,
+    root: options.root,
+    mode: options.mode,
+    env: options.env,
+    directive: options.directive,
+    sourceMap: true,
+    register: options.definitions.register,
+    create: options.definitions.create
+  });
+  return {
+    valid: result.valid,
+    code: result.code,
+    map: result.map ?? null,
+    functions: result.functions
+  };
+}
+
+// @ts-nocheck
+/**
+ * Hoisted from solid-start (packages/start/src/directives/xxhash32.ts).
+ *
+ * Copyright (c) 2019 Jason Dent
+ * https://github.com/Jason3S/xxhash
+ */
+const PRIME32_1 = 2654435761;
+const PRIME32_2 = 2246822519;
+const PRIME32_3 = 3266489917;
+const PRIME32_4 = 668265263;
+const PRIME32_5 = 374761393;
+function toUtf8(text) {
+  const bytes = [];
+  for (let i = 0, n = text.length; i < n; ++i) {
+    const c = text.charCodeAt(i);
+    if (c < 0x80) {
+      bytes.push(c);
+    } else if (c < 0x800) {
+      bytes.push(0xc0 | c >> 6, 0x80 | c & 0x3f);
+    } else if (c < 0xd800 || c >= 0xe000) {
+      bytes.push(0xe0 | c >> 12, 0x80 | c >> 6 & 0x3f, 0x80 | c & 0x3f);
+    } else {
+      const cp = 0x10000 + ((c & 0x3ff) << 10 | text.charCodeAt(++i) & 0x3ff);
+      bytes.push(0xf0 | cp >> 18 & 0x7, 0x80 | cp >> 12 & 0x3f, 0x80 | cp >> 6 & 0x3f, 0x80 | cp & 0x3f);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+
+/**
+ * @param buffer - byte array or string
+ * @param seed - optional seed (32-bit unsigned)
+ */
+function xxHash32(buffer, seed = 0) {
+  buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
+  const b = buffer;
+
+  // Step 1. Initialize internal accumulators
+  let acc = seed + PRIME32_5 & 0xffffffff;
+  let offset = 0;
+  if (b.length >= 16) {
+    const accN = [seed + PRIME32_1 + PRIME32_2 & 0xffffffff, seed + PRIME32_2 & 0xffffffff, seed + 0 & 0xffffffff, seed - PRIME32_1 & 0xffffffff];
+
+    // Step 2. Process stripes (16 bytes = 4 lanes of 4 bytes)
+    const b = buffer;
+    const limit = b.length - 16;
+    let lane = 0;
+    for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
+      const i = offset;
+      const laneN0 = b[i + 0] + (b[i + 1] << 8);
+      const laneN1 = b[i + 2] + (b[i + 3] << 8);
+      const laneNP = laneN0 * PRIME32_2 + (laneN1 * PRIME32_2 << 16);
+      let acc = accN[lane] + laneNP & 0xffffffff;
+      acc = acc << 13 | acc >>> 19;
+      const acc0 = acc & 0xffff;
+      const acc1 = acc >>> 16;
+      accN[lane] = acc0 * PRIME32_1 + (acc1 * PRIME32_1 << 16) & 0xffffffff;
+      lane = lane + 1 & 0x3;
+    }
+
+    // Step 3. Accumulator convergence
+    acc = (accN[0] << 1 | accN[0] >>> 31) + (accN[1] << 7 | accN[1] >>> 25) + (accN[2] << 12 | accN[2] >>> 20) + (accN[3] << 18 | accN[3] >>> 14) & 0xffffffff;
+  }
+
+  // Step 4. Add input length
+  acc = acc + buffer.length & 0xffffffff;
+
+  // Step 5. Consume remaining input (up to 15 bytes)
+  const limit = buffer.length - 4;
+  for (; offset <= limit; offset += 4) {
+    const i = offset;
+    const laneN0 = b[i + 0] + (b[i + 1] << 8);
+    const laneN1 = b[i + 2] + (b[i + 3] << 8);
+    const laneP = laneN0 * PRIME32_3 + (laneN1 * PRIME32_3 << 16);
+    acc = acc + laneP & 0xffffffff;
+    acc = acc << 17 | acc >>> 15;
+    acc = (acc & 0xffff) * PRIME32_4 + ((acc >>> 16) * PRIME32_4 << 16) & 0xffffffff;
+  }
+  for (; offset < b.length; ++offset) {
+    const lane = b[offset];
+    acc += lane * PRIME32_5;
+    acc = acc << 11 | acc >>> 21;
+    acc = (acc & 0xffff) * PRIME32_1 + ((acc >>> 16) * PRIME32_1 << 16) & 0xffffffff;
+  }
+
+  // Step 6. Final mix (avalanche)
+  acc ^= acc >>> 15;
+  acc = ((acc & 0xffff) * PRIME32_2 & 0xffffffff) + ((acc >>> 16) * PRIME32_2 << 16);
+  acc ^= acc >>> 13;
+  acc = ((acc & 0xffff) * PRIME32_3 & 0xffffffff) + ((acc >>> 16) * PRIME32_3 << 16);
+  acc ^= acc >>> 16;
+
+  // turn any negatives back into a positive number;
+  return acc < 0 ? acc + 4294967296 : acc;
+}
+
+// Hoisted from solid-start (packages/start/src/directives/index.ts).
+//
+// Standalone `"use server"` support for Vite. The compiler half of server
+// functions lives here; the runtime half (registration on the server, a
+// transport on the client) is @solidjs/web/server-functions by default —
+// the compiled output imports `registerServerReference` /
+// `createServerReference` from that specifier and the package's export
+// conditions resolve the right half per environment. Any runtime satisfying
+// that contract can be swapped in through `options.runtime` (SolidStart's,
+// or your own).
+
+/**
+ * Picomatch patterns selecting the modules the directive compiler runs on.
+ * Relative patterns (the defaults included) are resolved against the Vite
+ * root — not the invocation directory — so running `vite` from outside the
+ * project keeps compiling the same files. Absolute patterns are used as-is.
+ *
+ * @default include "src/**\/*.{jsx,tsx,ts,js,mjs,cjs}", exclude "node_modules/**\/*.{jsx,tsx,ts,js,mjs,cjs}"
+ */
+
+const DEFAULT_INCLUDE = 'src/**/*.{jsx,tsx,ts,js,mjs,cjs}';
+const DEFAULT_EXCLUDE = 'node_modules/**/*.{jsx,tsx,ts,js,mjs,cjs}';
+const DEFAULT_MANIFEST = 'virtual:solid-server-function-manifest';
+const DEFAULT_DIRECTIVE = 'use server';
+const DEFAULT_RUNTIME = '@solidjs/web/server-functions';
+// Must match the runtime's built-in default — when the resolved endpoint
+// equals it, no configure calls need to be emitted at all.
+const DEFAULT_ENDPOINT = '/_server';
+const STORAGE_SOURCE$1 = '@solidjs/web/storage';
+// Server-only handler: importing it wires the endpoint in one line
+// (registrations via the manifest, request-event scoping, endpoint config).
+const HANDLER_ID$1 = 'virtual:solid-server-function-handler';
+
+// Server functions referenced only from client-side code (e.g. event
+// handlers, which the SSR JSX compile drops) never get imported — or even
+// transformed — by the server build, so their registrations would be missing
+// at runtime. That's why the client transform records modules into the
+// *server* manifest set. The dev server and Vite's builder mode share one
+// process where that just works; the classic two-invocation build
+// (`vite build` then `vite build --ssr`) does not, so the client build
+// persists its findings for the SSR build to merge (mirroring the plugin's
+// dist/client/.vite/manifest.json convention).
+const PERSISTED_MANIFEST_PATH = '.vite/solid-server-functions.json';
+function readPersistedManifest(root) {
+  const file = path.resolve(root, 'dist/client', PERSISTED_MANIFEST_PATH);
+  if (!fs.existsSync(file)) return new Set();
+  try {
+    const entries = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    return new Set(entries.map(entry => path.resolve(root, entry)).filter(entry => fs.existsSync(entry)));
+  } catch {
+    return new Set();
+  }
+}
+function writePersistedManifest(root, outDir, entries) {
+  const file = path.resolve(root, outDir, PERSISTED_MANIFEST_PATH);
+  fs.mkdirSync(path.dirname(file), {
+    recursive: true
+  });
+  const relative = [...entries].map(entry => path.relative(root, entry).split(path.sep).join('/'));
+  fs.writeFileSync(file, JSON.stringify(relative, null, 2));
+}
+function createManifest() {
+  return {
+    server: new Set(),
+    client: new Set()
+  };
+}
+function createDeferredPromise() {
+  let resolve;
+  let reject;
+  return {
+    reference: new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    }),
+    resolve(value) {
+      resolve(value);
+    },
+    reject(value) {
+      reject(value);
+    }
+  };
+}
+
+// The manifest can only be emitted once every module has been transformed
+// (each transform may register new entries), but Vite gives no such signal —
+// so the manifest load resolves a debounced snapshot that transforms keep
+// pushing back while they are still landing.
+class Debouncer {
+  constructor(source) {
+    this.source = source;
+    this.promise = createDeferredPromise();
+    this.defer();
+  }
+  defer() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = undefined;
+    }
+    this.timeout = setTimeout(() => {
+      this.promise.resolve(this.source());
+    }, 1000);
+  }
+}
+function mergeManifestRecord(source, target) {
+  const current = source.size;
+  for (const entry of target) {
+    source.add(entry);
+  }
+  return {
+    invalidPreload: current !== source.size,
+    invalidated: [...source]
+  };
+}
+function invalidateModule(moduleGraph, path) {
+  const target = moduleGraph.getModuleById(path);
+  if (target) {
+    moduleGraph.invalidateModule(target);
+  }
+}
+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);
+  }
+}
+
+/**
+ * The second parameter is internal wiring for the main plugin's
+ * `serverFunctions` option: the built-in dev middleware is only installed
+ * through that path, so meta-frameworks composing this factory directly
+ * (and dispatching to `handleServerFunctionRequest` themselves) never race
+ * it for the endpoint. On the main plugin's path the public
+ * `options.devMiddleware` (default true) can opt back out of it.
+ */
+function serverFunctions(options = {}, internal = {}) {
+  const filterInclude = options.filter?.include || DEFAULT_INCLUDE;
+  const filterExclude = options.filter?.exclude || DEFAULT_EXCLUDE;
+  // Recreated in configResolved: relative patterns (the defaults included)
+  // must resolve against the Vite root, not process.cwd() — running `vite`
+  // from outside the project would otherwise silently skip every module.
+  let filter = vite.createFilter(filterInclude, filterExclude);
+  const manifestId = options.manifest || DEFAULT_MANIFEST;
+  const directive = options.directive || DEFAULT_DIRECTIVE;
+  const runtime = options.runtime || {
+    server: DEFAULT_RUNTIME,
+    client: DEFAULT_RUNTIME
+  };
+  const endpointOption = options.endpoint || DEFAULT_ENDPOINT;
+  const endpoint = endpointOption.startsWith('/') ? endpointOption : '/' + endpointOption;
+  const components = !!options.components;
+  // The middleware only exists on the main plugin's path to begin with (see the
+  // `internal` parameter doc); the public option opts out of it there.
+  const installDevMiddleware = !!internal.devMiddleware && options.devMiddleware !== false;
+  let env;
+  let root = process.cwd();
+  let base = '/';
+  let isBuild = false;
+  let isSsrBuild = false;
+  let outDir = 'dist';
+  // Endpoint with Vite `base` applied; final after configResolved, which
+  // runs before every transform/load/middleware that reads it.
+  let resolvedEndpoint = endpoint;
+  // Absolute path of the user's `configure` module; resolved (and existence-
+  // checked) in configResolved, before any handler load can read it.
+  let configureModulePath = null;
+  const manifest = createManifest();
+  const preload = {
+    server: undefined,
+    client: undefined
+  };
+  let currentServer;
+  const clientOptions = {
+    directive,
+    definitions: {
+      register: {
+        kind: 'named',
+        name: 'registerServerReference',
+        source: runtime.client
+      },
+      create: {
+        kind: 'named',
+        name: 'createServerReference',
+        source: runtime.client
+      }
+    }
+  };
+  const serverOptions = {
+    directive,
+    definitions: {
+      register: {
+        kind: 'named',
+        name: 'registerServerReference',
+        source: runtime.server
+      },
+      create: {
+        kind: 'named',
+        name: 'createServerReference',
+        source: runtime.server
+      }
+    }
+  };
+
+  // A non-default endpoint (custom option, or Vite `base` prefixing the
+  // default) must reach the runtime on both sides — the client transport
+  // reads it for every fetch, the server for rendered reference `.url`s.
+  // References are only reachable through compiled modules, so appending the
+  // configure call to each guarantees it runs before any reference is used.
+  // The default endpoint appends nothing, keeping compiled output byte-
+  // identical for setups that wire the runtime themselves.
+  function endpointConfigureSnippet(mode) {
+    if (resolvedEndpoint === DEFAULT_ENDPOINT) return '';
+    const name = mode === 'server' ? 'configureServerFunctionsServer' : 'configureServerFunctionsClient';
+    const source = mode === 'server' ? runtime.server : runtime.client;
+    return `\nimport { ${name} as $$configureServerFunctions } from ${JSON.stringify(source)};` + `\n$$configureServerFunctions({ endpoint: ${JSON.stringify(resolvedEndpoint)} });\n`;
+  }
+
+  // Dev omits the manifest import: the middleware loads the referenced
+  // module on demand instead (importing the debounced manifest would stall
+  // the first request and eagerly SSR-load every server-function module).
+  // Builds import it so tree-shaking can't drop registrations for functions
+  // only client code references.
+  function handlerModuleCode(includeManifest) {
+    // Server components ride the frame-stream wire protocol: the transform
+    // serves a function's component result as streamed HTML instead of data.
+    // Installing it here (config-level, merged with the other keys) covers
+    // both dispatch surfaces — the dev middleware and the prod handler load
+    // this module before dispatching — with zero per-request wiring. The
+    // import is only emitted when the option is on, so disabled setups keep
+    // a server-component-free graph.
+    return [
+    // The user's `configure` module comes first: a side-effect import in
+    // the handler graph, evaluated before any dispatch on both surfaces
+    // (dev middleware and prod handler) and bundled into the handler
+    // chunk by production builds. Order relative to the configure call
+    // below doesn't actually matter — runtime config merges per key —
+    // import-first is just the cleaner shape.
+    ...(configureModulePath ? [`import ${JSON.stringify(configureModulePath)};`] : []), ...(includeManifest ? [`import ${JSON.stringify(manifestId)};`] : []), `import { handleServerFunctionRequest as handle, configureServerFunctionsServer } from ${JSON.stringify(runtime.server)};`, `import { provideRequestEvent } from ${JSON.stringify(STORAGE_SOURCE$1)};`, ...(components ? [`import { frameTransformResult, frameTransformFlightResult, frameTransformDirectResult } from '@solidjs/web/frames';`] : []),
+    // `transformFlightResult` is the single-flight leg of the same wire
+    // protocol: a mutation whose invalidated payload includes markup gets
+    // the frame stream as its carrier (regions + envelope in one
+    // response). It only runs when a router registered a collectFlightData
+    // hook, so installing it unconditionally alongside the result
+    // transform costs disabled setups nothing.
+    //
+    // `transformDirectResult` is ALSO installed here — not just in the
+    // generated SSR entry — because flight collection makes direct
+    // (in-process) calls during handler dispatch, and the transform is what
+    // brands their results with the call address the client matches showing
+    // boundaries against. The SSR entry usually loads first and installs
+    // the same value (config merges per key), but the handler graph cannot
+    // depend on that: in dev, a mutation from an already-open page can be
+    // the first request after a server restart.
+    `configureServerFunctionsServer({ provideEvent: provideRequestEvent, endpoint: ${JSON.stringify(resolvedEndpoint)}${components ? ', transformResult: frameTransformResult, transformFlightResult: frameTransformFlightResult, transformDirectResult: frameTransformDirectResult' : ''} });`, `export const endpoint = ${JSON.stringify(resolvedEndpoint)};`, `export function handleServerFunctionRequest(request, options) {`, `  return handle(request, { provideEvent: provideRequestEvent, ...options });`, `}`].join('\n');
+  }
+
+  // Function IDs are `xxHash32(root-relative path)-<count>` (see compile.ts),
+  // so the hash segment maps an incoming ID back to its module. Rebuilt
+  // whenever a transform has grown the manifest.
+  const hashIndex = new Map();
+  let hashIndexSize = -1;
+  function moduleForFunctionId(functionId) {
+    if (manifest.server.size !== hashIndexSize) {
+      hashIndex.clear();
+      for (const entry of manifest.server) {
+        const relative = path.relative(root, entry).split(path.sep).join('/');
+        hashIndex.set(xxHash32(relative).toString(16), entry);
+      }
+      hashIndexSize = manifest.server.size;
+    }
+    return hashIndex.get(functionId.split('-', 1)[0]);
+  }
+  function moduleDevUrl(entry) {
+    const relative = path.relative(root, entry).split(path.sep).join('/');
+    return relative.startsWith('..') ? '/@fs/' + entry : '/' + relative;
+  }
+  const turnkeyPlugins = [{
+    name: 'solid:server-functions/handler',
+    enforce: 'pre',
+    resolveId(source, _importer, opts) {
+      if (source === HANDLER_ID$1) {
+        if (!opts?.ssr) {
+          this.error(`${HANDLER_ID$1} is server-only; import it from your server entry (SSR build).`);
+        }
+        return {
+          id: HANDLER_ID$1,
+          moduleSideEffects: true
+        };
+      }
+      return null;
+    },
+    load(id, opts) {
+      if (id === HANDLER_ID$1 && opts?.ssr) {
+        const externalDev = this.environment.mode === 'dev' && (internal.externalDevServer || !isRunnableEnvironment(this.environment));
+        return handlerModuleCode(isBuild || externalDev);
+      }
+      return null;
+    }
+  }];
+  if (installDevMiddleware) {
+    turnkeyPlugins.push({
+      name: 'solid:server-functions/dev-middleware',
+      apply: 'serve',
+      configureServer(server) {
+        const ssrEnvironment = server.environments.ssr;
+        if (internal.externalDevServer || ssrEnvironment && !isRunnableEnvironment(ssrEnvironment)) {
+          return;
+        }
+        server.middlewares.use((req, res, next) => {
+          const url = new URL(req.url || '/', 'http://localhost');
+          // Match with and without `base` — middleware-mode hosts may mount
+          // vite.middlewares below the base themselves.
+          if (url.pathname !== resolvedEndpoint && url.pathname !== endpoint) {
+            return next();
+          }
+          // When the stripped form matched, restore the base for dispatch:
+          // the generated handler compares the request pathname against the
+          // base-prefixed endpoint, and production handlers only ever see
+          // base-prefixed URLs.
+          const dispatchUrl = url.pathname === resolvedEndpoint ? undefined : joinBase(base, req.url || '/');
+          (async () => {
+            // Make sure the referenced module has been evaluated in the SSR
+            // environment so its registration exists — functions only client
+            // code references are never loaded by the SSR render itself.
+            const headerId = req.headers['x-server-function-id'];
+            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));
+            }
+            // Dispatch through a module evaluated in the SSR environment so
+            // the handler shares the registry instance with the app modules.
+            // With SSR start mode active the main plugin threads its handler id
+            // 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 response = internal.ssrHandler ? await handler.handleRequest(webRequestFromNode(req, dispatchUrl)) : await handler.handleServerFunctionRequest(webRequestFromNode(req, dispatchUrl));
+            await sendWebResponse(res, response);
+          })().catch(error => {
+            if (error instanceof Error) server.ssrFixStacktrace(error);
+            next(error);
+          });
+        });
+      }
+    });
+  }
+  return [{
+    name: 'solid:server-functions/setup',
+    enforce: 'pre',
+    configResolved(config) {
+      env = config.mode !== 'production' ? 'development' : 'production';
+      root = config.root;
+      base = config.base;
+      filter = vite.createFilter(filterInclude, filterExclude, {
+        resolve: root
+      });
+      isBuild = config.command === 'build';
+      isSsrBuild = !!config.build.ssr;
+      outDir = config.build.outDir;
+      resolvedEndpoint = joinBase(config.base, endpoint);
+      if (options.configure) {
+        const absolute = path.isAbsolute(options.configure) ? options.configure : path.resolve(root, options.configure);
+        if (!fs.existsSync(absolute)) {
+          throw new Error(`[@solidjs/vite-plugin] serverFunctions.configure does not exist: ${options.configure}`);
+        }
+        configureModulePath = absolute;
+      }
+      if (isBuild && isSsrBuild) {
+        // Classic two-invocation build: pick up the modules the client
+        // build discovered so the server manifest registers them even when
+        // the SSR module graph never imports them.
+        for (const entry of readPersistedManifest(root)) {
+          manifest.server.add(entry);
+        }
+      }
+    },
+    configureServer(server) {
+      currentServer = server;
+    },
+    writeBundle() {
+      // Same client-build detection as the main plugin: builder-mode builds
+      // run both environments in one process, so prefer the per-environment
+      // consumer over the process-wide --ssr flag.
+      const ctx = this;
+      const consumer = ctx.environment?.config?.consumer;
+      const isClient = consumer ? consumer === 'client' : !isSsrBuild;
+      if (isBuild && isClient) {
+        writePersistedManifest(root, outDir, manifest.server);
+      }
+    }
+  }, {
+    name: 'solid:server-functions/manifest',
+    enforce: 'pre',
+    resolveId(source) {
+      if (source === manifestId) {
+        return {
+          id: manifestId,
+          moduleSideEffects: true
+        };
+      }
+      return null;
+    },
+    async load(id, opts) {
+      const mode = opts?.ssr ? 'server' : 'client';
+      if (id === manifestId) {
+        if (isBuild && mode === 'server') {
+          // Merge the client build's persisted discoveries at load time,
+          // not just configResolved: in builder mode (single process,
+          // `vite build` with the environments API) all environment
+          // configs resolve before the client build has written the file,
+          // but this load runs once the SSR environment builds — after it.
+          for (const entry of readPersistedManifest(root)) {
+            manifest.server.add(entry);
+          }
+        }
+        const current = new Debouncer(() => [...manifest[mode]].map(entry => `import ${JSON.stringify(entry)};`).join('\n'));
+        preload[mode] = current;
+        const result = await current.promise.reference;
+        return result;
+      }
+      return null;
+    }
+  }, {
+    name: 'solid:server-functions/compiler',
+    enforce: 'pre',
+    async transform(code, fileId, opts) {
+      const mode = opts?.ssr ? 'server' : 'client';
+      const [id] = fileId.split('?');
+      if (!filter(id)) {
+        return null;
+      }
+
+      // Fast path: the directive has to appear literally, so anything
+      // without the substring can skip the native parse entirely.
+      if (!code.includes(directive)) {
+        return null;
+      }
+      const result = await compile(id, code, {
+        ...(mode === 'server' ? serverOptions : clientOptions),
+        mode,
+        env,
+        root
+      });
+      if (result.valid) {
+        const preloader = preload[mode];
+        if (preloader) {
+          preloader.defer();
+        }
+        invalidateModules(currentServer, mergeManifestRecord(manifest.server, new Set([id])), manifestId);
+        return {
+          // Appended (not prepended) so the source map for the compiled
+          // module stays valid; imports hoist and the endpoint is only
+          // read at call time, never during module evaluation.
+          code: (result.code || '') + endpointConfigureSnippet(mode),
+          map: result.map
+        };
+      }
+      return null;
+    }
+  }, ...turnkeyPlugins];
+}
+
+// Start-mode serving for plain Vite apps: `solid({ start: {...} })` (or the
+// zero-config sugar `start: true`) adds a serving layer with conventional
+// entries so no hand-rolled wiring is needed, and the plugin's `ssr`
+// boolean picks the mode — `ssr: true` server-renders the app per request;
+// `ssr: false`/omitted is client mode (the same conventions, but the
+// document shell is served/prerendered empty and the app `render()`s
+// client-side). The flip between them is that one boolean.
+//
+// SSR mode (`start` + `ssr: true`):
+// - Dev: runnable SSR environments are served by a Vite middleware. Provider-
+//   owned environments serve through `virtual:solid-ssr-handler` instead.
+//   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
+//   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
+//   with `provideRequestEvent`, stream the render, and resolve hashed client
+//   assets through `virtual:solid-manifest`.
+// - Entries are conventional with escape hatches: `src/entry-server.*` /
+//   `src/entry-client.*` are used when present (or set explicitly); when
+//   absent, default entries are generated from a single root component
+//   (`start.app`, defaulting to `src/App.*`) wrapped in a document shell
+//   (`start.document`, defaulting to `src/Document.*`, else a built-in one).
+// - When `serverFunctions` is also enabled, the handler composes the
+//   endpoint on every surface; the runnable-dev server-function middleware
+//   pre-loads the referenced module, then dispatches through this handler.
+// - Every dispatch runs under a stub-backed request event
+//   (`createRequestEvent`) with the optional `start.middleware` chain fronting
+//   it, and page responses go through the runtime's `createSSRResponse`
+//   head lifecycle (commit at shell flush, real pre-flush redirects, the
+//   script fallback post-flush).
+// - `vite preview` serves dist/client statically and dispatches everything
+//   else through the built handler — the production path, middleware
+//   included, with no server file needed.
+//
+// Client mode (`start` without `ssr: true`) rides the same machinery with
+// three deltas: the generated server entry renders the document shell
+// WITHOUT the app (dev serving doubles as history fallback, and a
+// post-build hook prerenders it once into dist/client/index.html), the
+// generated client entry render()s instead of hydrating, and dist/server is
+// dropped from the output unless `serverFunctions` needs it for the
+// endpoint. Client code compiles non-hydratable, exactly like a plain SPA.
+
+/**
+ * Options for the main plugin's `start` option (`start: true` is
+ * sugar for the empty bag). One bag serves both modes — the plugin's `ssr`
+ * boolean picks between them, so flipping a project between
+ * client-rendered and server-rendered is toggling that boolean, never
+ * reshaping this object. Server-only options (`entryServer`, `external`)
+ * are documented no-ops in client mode: they stay in the config across a
+ * flip instead of erroring.
+ */
+
+// Server-only start-mode request handler; also the server bundle's entry so a
+// production server is one import away from `Request -> Response`. Exported
+// for the main plugin to thread into the server-function dev middleware,
+// which dispatches through it when SSR start mode is active (one middleware
+// chain and one request event across both dispatch paths).
+const SSR_HANDLER_ID = 'virtual:solid-ssr-handler';
+const HANDLER_ID = SSR_HANDLER_ID;
+// Dev-only response marker: the generated dev handler answers non-page
+// requests that fell through the whole middleware chain to the terminal
+// page dispatch with a marked 404 instead of rendering HTML at them, and
+// the dev middleware hands those back to Vite's pipeline. Production has no
+// such seam — every unhandled request renders — but production also has no
+// Vite pipeline to fall back to.
+const DEV_FALLTHROUGH_HEADER = 'x-solid-dev-fallthrough';
+// Private protocol between the two generated modules when `start.setup` is
+// async: the entry hands the handler the renderToStream result under this
+// key, because a promise resolving to the stream BARE would adopt the
+// stream's thenable (which waits for the complete render) and buffer it.
+const STREAM_BOX = '__solidSetupStream';
+const DEV_STYLES_ID = 'virtual:solid-ssr-dev-styles';
+const RESOLVED_DEV_STYLES_ID = '\0' + DEV_STYLES_ID;
+// Generated default entries / document shell. The `.tsx` suffix routes them
+// through the plugin's normal JSX transform (per-environment SSR/DOM
+// compile), exactly like user-authored entry files.
+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 MANIFEST_ID = 'virtual:solid-manifest';
+const SERVER_FUNCTION_HANDLER_ID = 'virtual:solid-server-function-handler';
+const STORAGE_SOURCE = '@solidjs/web/storage';
+const ENTRY_EXTENSIONS = ['.tsx', '.jsx', '.ts', '.js', '.mjs'];
+const APP_EXTENSIONS = ['.tsx', '.jsx', '.ts', '.js'];
+const DOCUMENT_EXTENSIONS = ['.tsx', '.jsx'];
+function probe(root, stem, extensions) {
+  for (const ext of extensions) {
+    if (fs.existsSync(path.resolve(root, stem + ext))) return stem + ext;
+  }
+  return null;
+}
+
+/** Normalizes a user-supplied module path to a root-relative one (no leading slash). */
+function normalizeUserPath(root, spec, option) {
+  const absolute = path.isAbsolute(spec) ? spec : path.resolve(root, spec);
+  if (!fs.existsSync(absolute)) {
+    throw new Error(`[@solidjs/vite-plugin] start.${option} does not exist: ${spec}`);
+  }
+  const relative = path.relative(root, absolute).split(path.sep).join('/');
+  if (relative.startsWith('..')) {
+    throw new Error(`[@solidjs/vite-plugin] start.${option} must live inside the Vite root: ${spec}`);
+  }
+  return relative;
+}
+function resolveEntries(root, options, clientMode) {
+  const explicitClient = options.entryClient ? normalizeUserPath(root, options.entryClient, 'entryClient') : null;
+  if (clientMode) {
+    // Client mode: the server entry is always generated (it renders the
+    // document shell only — no App — for dev serving and the build-time
+    // prerender); `start.entryServer` and conventional src/entry-server.*
+    // files are documented no-ops here, so a project flipping the `ssr`
+    // boolean never has to touch them. No entry pairing rule either: an
+    // authored client entry stands alone. The document resolves in every
+    // case because it IS the page in this mode.
+    const document = options.document ? normalizeUserPath(root, options.document, 'document') : probe(root, 'src/Document', DOCUMENT_EXTENSIONS);
+    const entryClient = explicitClient ?? probe(root, 'src/entry-client', ENTRY_EXTENSIONS);
+    if (entryClient) {
+      return {
+        entryServer: ENTRY_SERVER_ID,
+        entryClient,
+        generated: false,
+        app: null,
+        document: document ? path.resolve(root, document) : null
+      };
+    }
+    const app = options.app ? normalizeUserPath(root, options.app, 'app') : probe(root, 'src/App', APP_EXTENSIONS) ?? probe(root, 'src/app', APP_EXTENSIONS);
+    if (!app) {
+      throw new Error(`[@solidjs/vite-plugin] the \`start\` option needs an app root: add src/App.tsx ` + `(or set start.app), or provide a src/entry-client.* entry.`);
+    }
+    return {
+      entryServer: ENTRY_SERVER_ID,
+      entryClient: ENTRY_CLIENT_ID,
+      generated: true,
+      app: path.resolve(root, app),
+      document: document ? path.resolve(root, document) : null
+    };
+  }
+  const explicitServer = options.entryServer ? normalizeUserPath(root, options.entryServer, 'entryServer') : null;
+  const entryServer = explicitServer ?? probe(root, 'src/entry-server', ENTRY_EXTENSIONS);
+  const entryClient = explicitClient ?? probe(root, 'src/entry-client', ENTRY_EXTENSIONS);
+  if (entryServer && entryClient) {
+    return {
+      entryServer,
+      entryClient,
+      generated: false,
+      app: null,
+      document: null
+    };
+  }
+  if (entryServer || entryClient) {
+    // One authored entry with a generated counterpart is a hydration
+    // mismatch waiting to happen — the generated side wraps the app in the
+    // document shell, which the authored side knows nothing about.
+    const found = entryServer ? 'entry-server' : 'entry-client';
+    const missing = entryServer ? 'entry-client' : 'entry-server';
+    throw new Error(`[@solidjs/vite-plugin] found ${found} but no ${missing}; entry files come in pairs. ` + `Provide both (src/entry-server.* and src/entry-client.*, or the start.entryServer / ` + `start.entryClient options) or neither (to generate both from start.app).`);
+  }
+  const app = options.app ? normalizeUserPath(root, options.app, 'app') : probe(root, 'src/App', APP_EXTENSIONS) ?? probe(root, 'src/app', APP_EXTENSIONS);
+  if (!app) {
+    throw new Error(`[@solidjs/vite-plugin] the \`start\` option needs an app root: add src/App.tsx ` + `(or set start.app), or provide src/entry-server.* and src/entry-client.* entries.`);
+  }
+  const document = options.document ? normalizeUserPath(root, options.document, 'document') : probe(root, 'src/Document', DOCUMENT_EXTENSIONS);
+  return {
+    entryServer: ENTRY_SERVER_ID,
+    entryClient: ENTRY_CLIENT_ID,
+    generated: true,
+    app: path.resolve(root, app),
+    document: document ? path.resolve(root, document) : null
+  };
+}
+function startServe(options, internal = {}) {
+  // Client mode (the `start` option without `ssr: true`) rides this exact
+  // plugin with three deltas: the generated server entry renders the
+  // document shell WITHOUT the app (dev serving doubles as history
+  // fallback, and a post-build hook prerenders it once into
+  // dist/client/index.html), the generated client entry render()s instead
+  // of hydrating, and dist/server is dropped from the output unless
+  // `serverFunctions` needs it for the endpoint. Everything else — entry
+  // probing, the handler, middleware, dev styles, the manifest — is shared,
+  // which is what makes flipping a project between the modes a one-boolean
+  // config change.
+  const clientMode = !internal.ssr;
+  // Server components (`serverFunctions: { components: true }`): generated
+  // entries additionally emit the document-SSR wiring — the render plugin +
+  // direct-call transform server-side, the bootstrap script in <head>, and
+  // the client-side installServerComponents() call. Authored entries carry
+  // those pieces themselves (the endpoint response transform is installed by
+  // 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;
+  // `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;
+  let root = process.cwd();
+  let base = '/';
+  let isBuild = false;
+  let entries;
+  /** Absolute path of the user's middleware module, when configured. */
+  let middlewarePath = null;
+  /** Absolute path of the per-request setup module, when configured (server mode). */
+  let setupPath = null;
+  function requireEntries() {
+    // config() always runs before resolveId/load/configureServer.
+    if (!entries) throw new Error('[@solidjs/vite-plugin] SSR entries not resolved yet');
+    return entries;
+  }
+
+  /** Import specifier for generated code: absolute for files, id for virtuals. */
+  function entryServerSpec() {
+    const {
+      entryServer
+    } = requireEntries();
+    return entryServer === ENTRY_SERVER_ID ? entryServer : path.resolve(root, entryServer);
+  }
+
+  /** Browser URL of the client entry on the dev server (base applied). */
+  function devClientEntryUrl() {
+    const {
+      entryClient
+    } = requireEntries();
+    return entryClient === ENTRY_CLIENT_ID ? joinBase(base, '/@id/' + ENTRY_CLIENT_ID) : joinBase(base, '/' + entryClient);
+  }
+  function documentSpec() {
+    const {
+      document
+    } = requireEntries();
+    return document ?? DOCUMENT_ID;
+  }
+  function styleRoots() {
+    const {
+      generated,
+      app,
+      document,
+      entryServer,
+      entryClient
+    } = requireEntries();
+    if (clientMode) {
+      // The app graph's CSS is inlined into the dev shell too (not just the
+      // document's): the client injects it again when the modules load and
+      // the dev style patch dedupes, so this is pure anti-flash.
+      return [generated ? app : path.resolve(root, entryClient), ...(document ? [document] : [])];
+    }
+    return generated ? [app, ...(document ? [document] : [])] : [path.resolve(root, entryServer)];
+  }
+  async function devStylesModuleCode(environment, watchFile) {
+    const styles = await collectDevStyleSources(environment, styleRoots(), watchFile);
+    if (!styles.length) return `export default '';`;
+    const imports = styles.map((style, index) => {
+      const specifier = style.url.includes('?') ? `${style.url}&inline` : `${style.url}?inline`;
+      return `import css${index} from ${JSON.stringify(specifier)};`;
+    });
+    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() {
+    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');
+    }
+    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 ? [
+    // 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
+    // server-function handler module (configure calls merge per key).
+    `configureServerFunctionsServer({ transformDirectResult: frameTransformDirectResult });`, ``] : []), ...(setupPath ? [
+    // The per-request seam: the hook sees the same event the
+    // middleware chain decorated and finishes before renderToStream
+    // starts. When it is async, the stream must NOT cross the
+    // promise boundary bare — a promise resolving to a
+    // renderToStream result adopts its thenable (which waits for
+    // 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');
+  }
+  function generatedEntryClientCode() {
+    const {
+      app
+    } = requireEntries();
+    if (clientMode) {
+      // render(), not hydrate(): the shell's body is empty, the app mounts
+      // fresh. Client code compiles non-hydratable in client mode, so the
+      // 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 { hydrate } from '@solidjs/web';`, ...(serverComponents ? [`import { installServerComponents } from '@solidjs/web/frames';`] : []), `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');
+  }
+
+  // Built-in document shell: minimal, hydration-ready. The client entry
+  // script is injected into <head> by the handler (not rendered here) so its
+  // URL never has to survive hydration or a manifest lookup client-side.
+  // The client-mode variant drops <HydrationScript /> — nothing hydrates,
+  // so the shell stays inert HTML. (A user-authored Document carrying
+  // 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');
+
+  // 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
+  // manifest scan) and what gets injected into <head> (Vite client + style
+  // patch in dev). The response-head lifecycle is the runtime's
+  // (`createRequestEvent`/`createSSRResponse`/`commitEventResponse` from
+  // @solidjs/web): every request runs under a stub-backed event,
+  // `httpStatus`/`httpHeader` writes land on the wire at shell flush, a
+  // pre-flush redirect becomes a real 3xx and a post-flush one the script
+  // fallback, and a Response that skipped the render lifecycle (middleware
+  // early return, raw entry.render Response, server functions) has the
+  // stub folded on at the handler edge after the middleware chain fully
+  // unwinds. When
+  // `serverFunctions` is enabled the endpoint is dispatched here on every
+  // surface (the runnable-dev middleware routes through this module), so
+  // user middleware and the shared request event front it identically.
+  function handlerModuleCode(externalDev) {
+    const {
+      generated,
+      entryClient
+    } = requireEntries();
+    const composeServerFunctions = internal.serverFunctions;
+    const lines = [`import { createRequestEvent, createSSRResponse, commitEventResponse${middlewarePath ? ', composeMiddleware' : ''} } from '@solidjs/web';`, `import { provideRequestEvent } from ${JSON.stringify(STORAGE_SOURCE)};`, `import * as entry from ${JSON.stringify(entryServerSpec())};`, ...(middlewarePath ? [`import middlewareModule from ${JSON.stringify(middlewarePath)};`] : []), ...(externalDev ? [`import DEV_STYLES_HEAD from ${JSON.stringify(DEV_STYLES_ID)};`] : []), ...(composeServerFunctions ? [`import { handleServerFunctionRequest, endpoint } from ${JSON.stringify(SERVER_FUNCTION_HANDLER_ID)};`] : [])];
+    if (isBuild) {
+      lines.push(`import manifest from ${JSON.stringify(MANIFEST_ID)};`);
+      lines.push(``, `function joinAssetPath(base, file) {`, `  if (typeof base !== 'string' || !base) base = '/';`, `  if (base[base.length - 1] !== '/') base += '/';`, `  return base + (file[0] === '/' ? file.slice(1) : file);`, `}`, ``, `let clientEntryUrl;`, `function resolveClientEntry() {`, `  if (clientEntryUrl !== undefined) return clientEntryUrl;`, `  clientEntryUrl = null;`,
+      // The plugin's manifest module normalizes lazy facade chunks
+      // (isDynamicEntry) so exactly one real entry remains flagged.
+      `  for (const key in manifest) {`, `    const chunk = manifest[key];`, `    if (chunk && chunk.isEntry && chunk.file) {`, `      clientEntryUrl = joinAssetPath(manifest._base, chunk.file);`, `      break;`, `    }`, `  }`, `  return clientEntryUrl;`, `}`);
+    } else {
+      const devHead = `<script>${devStylePatch}</script>` + `<script type="module" src="${joinBase(base, '/@vite/client')}"></script>`;
+      lines.push(``, `const DEV_HEAD = ${JSON.stringify(devHead)};`);
+    }
+
+    // Middleware: the user module default-exports one fetch-style function
+    // or an array, composed in order. Without one, the chain degenerates to
+    // the terminal dispatch.
+    lines.push(``);
+    if (middlewarePath) {
+      lines.push(`const middlewares = Array.isArray(middlewareModule) ? middlewareModule : [middlewareModule];`, `for (const mw of middlewares) {`, `  if (typeof mw !== 'function') {`, `    throw new Error('[@solidjs/vite-plugin] start.middleware must default-export a function or an array of functions: ' + ${JSON.stringify(middlewarePath)});`, `  }`, `}`, `const runMiddleware = composeMiddleware(middlewares);`);
+    } else {
+      lines.push(`const runMiddleware = (request, next) => next(request);`);
+    }
+
+    // No `_$SC` bootstrap injection: the runtime's serialized
+    // server-component references self-bootstrap the registry (each
+    // hydration script's first reference carries it as an idempotent
+    // expression), so nothing needs to precede the data scripts. The old
+    // 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) => {`);
+    if (!generated) {
+      // Authored entries reference the client entry by its dev path (the
+      // `<script src="/src/entry-client.tsx">` convention); rewrite it to
+      // the resolved URL like the classic server harnesses do.
+      lines.push(`    if (clientEntry && chunk.includes(${JSON.stringify('/' + entryClient)})) {`, `      chunk = chunk.split(${JSON.stringify('/' + entryClient)}).join(clientEntry);`, `    }`);
+    }
+    lines.push(`    if (!injected && chunk.includes('</head>')) {`, `      injected = true;`);
+    if (clientMode) {
+      // Nothing hydrates in client mode, so the event-capture bootstrap
+      // `<HydrationScript />` renders (`window._$HY||...`) is dead weight —
+      // but a Document shared with SSR mode carries it by design (the flip
+      // story). Strip it from the shell here instead of making users fork
+      // their Document per mode. (`<!--xs-->` is the script's stream
+      // marker; the shell head always arrives in one chunk.)
+      lines.push(`      chunk = chunk.replace(/<script(?:\\s[^>]*)?>window\\._\\$HY\\|\\|[\\s\\S]*?<\\/script>(?:<!--xs-->)?/, '');`);
+    }
+    const headParts = [];
+    // Dev: the style patch + Vite client, then either middleware-provided
+    // styles or the external environment's HMR-tracked virtual styles module.
+    if (!isBuild) {
+      headParts.push(`DEV_HEAD`, externalDev ? `(extraHead === undefined ? DEV_STYLES_HEAD : extraHead)` : `(extraHead || '')`);
+    }
+    if (generated || clientMode) {
+      // Client-mode note: the shell never references its client entry
+      // itself (even an authored one — the Document knows nothing about
+      // entries), so the handler always injects it. Without `async`: module
+      // 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>' : '')`);
+    }
+    if (headParts.length) {
+      lines.push(`      chunk = chunk.replace('</head>', ${headParts.join(' + ')} + '</head>');`);
+    }
+    lines.push(`    }`, `    if (first) { first = false; chunk = '<!DOCTYPE html>' + chunk; }`, `    return chunk;`, `  };`, `}`);
+
+    // The handler-edge commit fold — the runtime's `commitEventResponse`
+    // (named import above), the second of the response lifecycle's two
+    // exits: page results leave through `createSSRResponse`, any other
+    // Response (a middleware early return, a raw Response from
+    // entry.render, a server-function response) leaves through
+    // `commitEventResponse`, which folds the event's response stub onto it
+    // (cookies append entry-by-entry, other headers gap-fill, status stays
+    // the response's own) and commits the stub. Committed stubs pass
+    // through untouched, so the edge applies it unconditionally.
+    lines.push(``, `async function dispatchRequest(request, event, options) {`);
+    if (composeServerFunctions) {
+      lines.push(`  if (new URL(request.url).pathname === endpoint) {`,
+      // The call shares the middleware chain's event (locals decoration,
+      // the response stub); an explicit host-provided createEvent wins.
+      // No fold here: the runtime's server-function handler runs the
+      // commit seam itself, and anything it left uncommitted is caught by
+      // the unconditional edge fold in handleRequest.
+      `    return handleServerFunctionRequest(request, {`, `      createEvent: () => event,`, `      ...options.serverFunctions,`, `    });`, `  }`);
+    }
+    if (!isBuild) {
+      // Dev terminal gate: the dev middleware dispatches every request the
+      // middleware chain might handle (API routes, no-JS form POSTs — all
+      // methods and accept types, matching production), passing
+      // `pageRequest: false` for the non-page ones. When such a request
+      // falls through the whole chain to this terminal dispatch, nothing
+      // owns it — answer with the marked 404 so the dev middleware hands
+      // it back to Vite's pipeline instead of rendering HTML at it. The
+      // gate reflects the wire request: only the dev middleware sets the
+      // flag, so external-host dispatch and preview stay render-always.
+      lines.push(`  if (options.pageRequest === false) {`, `    return new Response(null, { status: 404, headers: { ${JSON.stringify(DEV_FALLTHROUGH_HEADER)}: '1' } });`, `  }`);
+    }
+    lines.push(isBuild ? `  const clientEntry = options.clientEntry || resolveClientEntry();` : `  const clientEntry = options.clientEntry || ${JSON.stringify(devClientEntryUrl())};`, `  let result = entry.render(request, { clientEntry, ...options.context });`,
+    // renderToStream results are thenables whose then() waits for the
+    // *complete* render — check for pipe first so streaming survives, and
+    // only await plain promises (async render functions).
+    `  if (result && typeof result.pipe !== 'function' && typeof result.then === 'function') {`, `    result = await result;`, `  }`, ...(setupPath ? [
+    // start.setup's async path boxes the stream (see the generated
+    // entry): a bare promise resolution would adopt the stream's
+    // thenable and buffer the whole render.
+    `  if (result && result.${STREAM_BOX}) result = result.${STREAM_BOX};`] : []),
+    // Raw Responses fold at the handler edge (handleRequest), after the
+    // middleware chain unwinds — not here, where middleware above this
+    // frame could still legitimately mutate headers.
+    `  if (result instanceof Response) return result;`,
+    // 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 = {}) {`, `  const event = createRequestEvent(request);`,
+    // Middleware runs inside the request scope, after event creation —
+    // getRequestEvent() answers in middleware exactly as in app code, and
+    // nothing reaches the wire until the outermost middleware returns.
+    `  const response = await provideRequestEvent(event, () =>`, `    runMiddleware(request, (req) => dispatchRequest(req || request, event, options)),`, `  );`,
+    // The fold runs strictly AFTER the outermost middleware returned:
+    // headers stay mutable through the whole unwind, and a middleware
+    // early return (an API handler that never called next()) gets its
+    // stub writes — cookies set inside the request scope, status — onto
+    // the wire. Unconditional: page responses come back from
+    // createSSRResponse committed and pass through untouched.
+    `  return commitEventResponse(response, event);`, `}`, ``, `export default {`, `  fetch(request) {`,
+    // Hosts may pass environment/context arguments after the request.
+    // Do not alias fetch directly to handleRequest: its second argument is
+    // the Solid handler options bag, not a provider binding object.
+    `    return handleRequest(request);`, `  },`, `};`);
+    return lines.join('\n');
+  }
+  return [{
+    name: 'solid:ssr/setup',
+    enforce: 'pre',
+    config(userConfig, env) {
+      root = path.resolve(userConfig.root || process.cwd());
+      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
+      // no-op in client mode so configs survive the `ssr` boolean flip).
+      setupPath = !clientMode && options.setup ? path.resolve(root, normalizeUserPath(root, options.setup, 'setup')) : null;
+      if (setupPath && !entries.generated) {
+        // An authored entry-server owns its render function — the seam the
+        // hook needs does not exist there.
+        throw new Error('[@solidjs/vite-plugin] start.setup only applies to generated entries: your ' + 'entry-server owns render() already, so call your setup step there instead ' + `(remove start.setup or the authored entry): ${options.setup}`);
+      }
+      if (env.isPreview) {
+        if (clientMode) {
+          // Client-mode builds emit a real dist/client/index.html (the
+          // prerendered shell), so preview is Vite's stock static +
+          // history-fallback story. When server functions are on, the
+          // endpoint dispatches through the kept dist/server handler
+          // (configurePreviewServer).
+          return {
+            appType: 'spa',
+            build: {
+              outDir: 'dist/client'
+            }
+          };
+        }
+        // `vite preview` serves `build.outDir` statically; point it at the
+        // client bundle so hashed assets resolve, while HTML (and
+        // everything else unhandled) falls through to the
+        // configurePreviewServer dispatch below. No index.html exists, so
+        // `custom` keeps preview from attempting an SPA fallback.
+        return {
+          appType: 'custom',
+          ...(externalServer ? {} : {
+            build: {
+              outDir: 'dist/client'
+            }
+          })
+        };
+      }
+      const build = env.command === 'build';
+      const clientInput = entries.generated ? ENTRY_CLIENT_ID : path.resolve(root, entries.entryClient);
+      // Real files only — the dep scanner can't crawl virtual modules.
+      // (In client mode the resolved document joins the scan/style roots
+      // even with an authored client entry; in SSR mode authored entries
+      // own the whole graph.)
+      const scanEntries = entries.generated ? [entries.app, ...(entries.document ? [entries.document] : [])] : [path.resolve(root, entries.entryClient), ...(clientMode && entries.document ? [entries.document] : [])];
+      return {
+        // No index.html: dev must not fall back to SPA-serving one, and
+        // the dep scanner needs explicit entries instead.
+        appType: 'custom',
+        ...(build ? externalServer ? {
+          environments: {
+            client: {
+              build: {
+                manifest: true,
+                rollupOptions: {
+                  input: clientInput
+                }
+              }
+            }
+          }
+        } : {
+          environments: {
+            client: {
+              build: {
+                manifest: true,
+                outDir: 'dist/client',
+                rollupOptions: {
+                  input: clientInput
+                }
+              }
+            },
+            ssr: {
+              consumer: 'server',
+              build: {
+                outDir: 'dist/server',
+                rollupOptions: {
+                  // `index` is the Vite service convention consumed
+                  // by provider orchestrators such as Nitro. Keep the
+                  // standalone artifact's established filename.
+                  input: {
+                    index: HANDLER_ID
+                  },
+                  output: {
+                    entryFileNames: 'server.js'
+                  }
+                }
+              }
+            }
+          },
+          // Presence of `builder` makes a plain `vite build` build the
+          // whole app (all environments: client then ssr) on Vite 6+.
+          // A classic `vite build --ssr` invocation must stay a
+          // single-environment build, so it doesn't get the flag.
+          ...(env.isSsrBuild ? {} : {
+            builder: {}
+          })
+        } : {
+          ...(!clientMode && !externalServer ? {
+            environments: {
+              ssr: {
+                consumer: 'server',
+                build: {
+                  outDir: 'dist/server',
+                  rollupOptions: {
+                    // Expose the same service entry during serve so
+                    // provider runtimes can discover and own it.
+                    input: {
+                      index: HANDLER_ID
+                    },
+                    output: {
+                      entryFileNames: 'server.js'
+                    }
+                  }
+                }
+              }
+            }
+          } : {}),
+          optimizeDeps: {
+            entries: scanEntries
+          }
+        })
+      };
+    },
+    configResolved(config) {
+      root = config.root;
+      base = config.base;
+      isBuild = config.command === 'build';
+    },
+    resolveId(source) {
+      if (source === HANDLER_ID) {
+        return {
+          id: HANDLER_ID,
+          moduleSideEffects: true
+        };
+      }
+      if (source === DEV_STYLES_ID) {
+        return {
+          id: RESOLVED_DEV_STYLES_ID,
+          moduleSideEffects: true
+        };
+      }
+      if (source === ENTRY_SERVER_ID || source === ENTRY_CLIENT_ID || source === DOCUMENT_ID) {
+        return {
+          id: source,
+          moduleSideEffects: source === ENTRY_CLIENT_ID
+        };
+      }
+      return null;
+    },
+    async load(id, opts) {
+      if (id === HANDLER_ID) {
+        if (!opts?.ssr) {
+          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') {
+          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 === DOCUMENT_ID) return documentShellCode;
+      return 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
+      // everything else — pages, the server-function endpoint, middleware
+      // included — dispatches through the built handler, exactly like a
+      // deployed server. Hosts owning the server build (`start.external`)
+      // preview through their own runner instead.
+      // Client mode: pages are the static index.html (preview's own
+      // history fallback serves them before this post middleware runs);
+      // only the server-function endpoint needs the handler, and without
+      // server functions there is no dist/server at all.
+      if (externalServer || clientMode && !internal.serverFunctions) return;
+      return () => {
+        let handlerPromise = null;
+        server.middlewares.use((req, res, next) => {
+          (async () => {
+            handlerPromise ??= import(node_url.pathToFileURL(path.resolve(root, 'dist/server/server.js')).href);
+            const handler = await handlerPromise;
+            // Preview's base middleware runs before this post hook and
+            // strips the configured `base` from req.url; the built handler
+            // compares pathnames against base-prefixed endpoints (the
+            // server-function endpoint) and hands the URL to application
+            // code, so restore the base — the deployed production handler
+            // receives base-prefixed URLs and preview must match it.
+            const response = await handler.handleRequest(webRequestFromNode(req, joinBase(base, req.url || '/')));
+            // Preview's compression middleware buffers whole responses;
+            // opting HTML out keeps SSR streaming observable, matching
+            // production behavior.
+            if ((response.headers.get('content-type') || '').includes('text/html')) {
+              res.setHeader('content-encoding', 'identity');
+            }
+            await sendWebResponse(res, response);
+          })().catch(next);
+        });
+      };
+    },
+    configureServer(server) {
+      // The files whose static import graphs carry the app's entry CSS:
+      // the app root (+ document) for generated entries, the authored
+      // server entry otherwise. Their transitively imported styles are
+      // inlined into <head> per request (Vite injects entry CSS from
+      // client JS only, so SSR'd markup would flash unstyled without
+      // this); the SSR'd tags carry data-asset + data-vite-dev-id so the
+      // dev style patch drops them once Vite's own injection takes over —
+      // exactly the lazy-asset dedup story, HMR included.
+      // Post middleware: Vite's own middlewares (transforms, static, the
+      // server-function endpoint) run first; whatever asks for HTML after
+      // that gets the streamed SSR render.
+      return () => {
+        const ssrEnvironment = server.environments.ssr;
+        if (externalServer || ssrEnvironment && !isRunnableEnvironment(ssrEnvironment)) {
+          return;
+        }
+        server.middlewares.use((req, res, next) => {
+          const url = new URL(req.url || '/', 'http://localhost');
+          if (url.pathname.startsWith('/@')) return next();
+          const accept = req.headers.accept || '';
+          const pageRequest = req.method === 'GET' && accept.includes('text/html');
+          // Production dispatches every request through the handler, so
+          // dev must too or API routes and no-JS form POSTs served by
+          // `start.middleware` are unreachable under `vite dev`. Without
+          // a middleware chain, non-page requests have nothing to reach —
+          // they stay on Vite's pipeline (404s) instead of rendering HTML.
+          if (!pageRequest && !middlewarePath) return next();
+          (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 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
+            // sees the same URLs in dev as in production (where the
+            // deployed handler receives base-prefixed requests).
+            const response = await handler.handleRequest(webRequestFromNode(req, joinBase(base, req.url || '/')), {
+              devHead,
+              pageRequest
+            });
+            // A non-page request the chain never handled: the terminal
+            // dispatch answered with the marked 404 — hand it back to
+            // Vite (its 404, other post middlewares) rather than sending
+            // a rendered page at a fetch()/form client.
+            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);
+          });
+        });
+      };
+    }
+  }, ...(clientMode ? [{
+    name: 'solid:start/prerender',
+    apply: 'build',
+    buildApp: {
+      // Post order: this hook owns the whole client-mode app build (the
+      // client-build-first orchestration pair is SSR-only). It
+      // builds client-then-ssr itself — building anything from a
+      // hook suppresses Vite's build-all fallback, so the ordering
+      // is guaranteed and the manifest is on disk before the shell
+      // bundle bakes it in — then runs the built handler once to
+      // prerender the shell into dist/client/index.html and drops
+      // dist/server unless server functions still need its handler.
+      // The shell arrives complete from the handler: the runtime
+      // registers every manifest entry's CSS during the render
+      // (registerEntryAssets), so the entry graph's stylesheet
+      // links are already in its head — injecting them here again
+      // double-links every stylesheet.
+      order: 'post',
+      async handler(builder) {
+        const client = builder.environments.client;
+        const ssrEnvironment = builder.environments.ssr;
+        if (client && !client.isBuilt) await builder.build(client);
+        if (ssrEnvironment && !ssrEnvironment.isBuilt) {
+          await builder.build(ssrEnvironment);
+        }
+        const serverDir = path.resolve(root, 'dist/server');
+        const handler = await import(node_url.pathToFileURL(path.join(serverDir, 'server.js')).href);
+        const response = await handler.handleRequest(new Request(new URL(base || '/', 'http://localhost')));
+        fs.writeFileSync(path.resolve(root, 'dist/client/index.html'), await response.text());
+        if (!internal.serverFunctions) {
+          fs.rmSync(serverDir, {
+            recursive: true,
+            force: true
+          });
+        }
+      }
+    }
+  }] : [])];
+}
+
+// Typed, validated environment variables as a start-mode feature (`start.env`):
+// an `env.ts` at the project root default-exports `{ server, client }` maps
+// of Standard Schema validators (zod, valibot, arktype — mixable per key),
+// and the plugin exposes the validated values through two virtual modules:
+//
+// - `virtual:env/server` — every var; importable only from server module
+//   graphs (a client-graph import is a hard error naming the importer).
+// - `virtual:env/client` — the `client` side only, whose keys must carry
+//   the public env prefix (`VITE_` unless `envPrefix` says otherwise).
+//
+// Validation runs at config/build time in node only, against Vite's
+// `loadEnv` merge of the `.env*` files with `process.env` winning (CI
+// secrets take precedence) — and the plugin folds the file-loaded vars into
+// `process.env` itself, so templates don't need the classic
+// `process.env = { ...process.env, ...loadEnv(mode, root, '') }` one-liner.
+//
+// Client values are baked into the bundles as validated plain JSON —
+// that's what the public `VITE_` prefix means — so no validator library
+// ever reaches a browser bundle. Server values are NOT baked anywhere:
+// `virtual:env/server` reads `process.env` at module init (server boot)
+// and validates through the user's own schema, which only the server
+// module graph imports. Platform-injected vars that don't exist at build
+// time work, secrets rotate without a rebuild, and no secret value exists
+// in any dist artifact. Build-time server-value failures downgrade to a
+// warning (boot enforces); dev failures stay hard errors — dev IS runtime.
+//
+// A failed validation fails the build; in dev it renders Vite's error
+// overlay with the per-key report (the virtual modules throw it on load)
+// and `.env*`/schema edits revalidate live. A `solid-env.d.ts` is generated
+// next to the schema file so both virtual modules are fully typed by
+// inference from the user's own schema — no manual declarations.
+//
+// Design credit: the shape of this feature — env.ts schema file, the
+// virtual module pair and their names, build-time validation with baked
+// JSON values, the leak scan — follows @vite-env/core by pyyupsk (MIT,
+// 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`
+// (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.
+const CLIENT_ENV_ID = 'virtual:env/client';
+const SERVER_ENV_ID = 'virtual:env/server';
+const RESOLVED_CLIENT_ENV_ID = '\0' + CLIENT_ENV_ID;
+const RESOLVED_SERVER_ENV_ID = '\0' + SERVER_ENV_ID;
+
+// Conventional schema locations, project-root relative. TypeScript first —
+// the whole point is inferred types — but a plain-JS project works too.
+const ENV_FILE_CANDIDATES = ['env.ts', 'env.js'];
+// Generated ambient types, written next to the schema file. Deliberately
+// NOT `env.d.ts`: a declaration file sharing the schema file's stem would
+// shadow it in TS resolution (and self-reference its own `typeof import`).
+const GENERATED_TYPES_FILE = 'solid-env.d.ts';
+
+/**
+ * The minimal structural slice of the Standard Schema v1 interface
+ * (https://standardschema.dev) this plugin consumes — the spec is designed
+ * to be vendored so validating libraries stay decoupled.
+ */
+
+function isStandardSchema(value) {
+  return !!value && typeof value === 'object' && typeof value['~standard']?.validate === 'function';
+}
+
+/**
+ * Keys the loadEnv fold added to process.env, tracked process-globally.
+ * Real environment always wins over files — but values *we* folded must not
+ * count as "real" on revalidation, or the first fold would pin every .env
+ * value forever and live edits would never be seen. Process-global (not
+ * plugin-closure) state because Vite restarts the dev server on .env
+ * changes, recreating the plugin instances inside the same node process:
+ * the new instance must be able to clear the old instance's fold.
+ */
+const FOLDED_KEYS = Symbol.for('@solidjs/vite-plugin:env-folded-keys');
+function foldedKeys() {
+  const holder = globalThis;
+  return holder[FOLDED_KEYS] ??= new Set();
+}
+function stringEntries(env) {
+  const out = {};
+  for (const key in env) {
+    const value = env[key];
+    if (typeof value === 'string') out[key] = value;
+  }
+  return out;
+}
+
+/** Formats the per-key validation report shared by builds and the dev overlay. */
+function formatValidationError(issues, envFile, mode) {
+  const lines = issues.map(({
+    key,
+    message
+  }) => `  ✗ ${key}: ${message}`);
+  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.
+ */
+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 => fs.existsSync(dep))
+    };
+  }
+  const result = await vite.loadConfigFromFile({
+    command: 'serve',
+    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 => fs.existsSync(dep))
+  };
+}
+function assertSchemaShape(exported, envFile, envPrefixes) {
+  if (!exported || typeof exported !== 'object') {
+    throw new Error(`[@solidjs/vite-plugin] ${envFile} must default-export an object of the shape ` + `{ server?: { VAR: schema }, client?: { VITE_VAR: schema } } where every schema ` + `is a Standard Schema validator (zod, valibot, arktype, ...). Got: ${exported === null ? 'null' : typeof exported}.`);
+  }
+  const schema = exported;
+  for (const key of Object.keys(schema)) {
+    if (key !== 'server' && key !== 'client') {
+      throw new Error(`[@solidjs/vite-plugin] unknown key "${key}" in ${envFile}: the env schema takes ` + `only \`server\` and \`client\` maps of Standard Schema validators.`);
+    }
+  }
+  for (const side of ['server', 'client']) {
+    const shape = schema[side];
+    if (shape === undefined) continue;
+    if (!shape || typeof shape !== 'object') {
+      throw new Error(`[@solidjs/vite-plugin] \`${side}\` in ${envFile} must be an object mapping variable ` + `names to Standard Schema validators.`);
+    }
+    for (const [key, validator] of Object.entries(shape)) {
+      if (!isStandardSchema(validator)) {
+        throw new Error(`[@solidjs/vite-plugin] ${side}.${key} in ${envFile} is not a Standard Schema ` + `validator (no callable \`~standard.validate\`). Any zod/valibot/arktype ` + `schema qualifies; plain values and functions don't.`);
+      }
+    }
+  }
+  const typed = schema;
+  for (const key of Object.keys(typed.client ?? {})) {
+    if (!envPrefixes.some(prefix => key.startsWith(prefix))) {
+      const wanted = envPrefixes[0] ?? 'VITE_';
+      throw new Error(`[@solidjs/vite-plugin] client env var "${key}" in ${envFile} must carry the public ` + `env prefix ("${envPrefixes.join('" or "')}") — client vars are baked into the ` + `browser bundle. Rename it to "${wanted}${key}", or move it to \`server\` if it ` + `is a secret.`);
+    }
+    if (typed.server && key in typed.server) {
+      throw new Error(`[@solidjs/vite-plugin] "${key}" is defined in both \`server\` and \`client\` in ` + `${envFile}; a variable belongs to exactly one side (\`client\` vars are ` + `visible to the server too).`);
+    }
+  }
+  // The reverse guard: Vite itself bakes every prefixed variable into
+  // `import.meta.env` for the browser, so declaring one under `server`
+  // cannot keep it secret — it leaks through Vite's channel with no
+  // diagnostics from this plugin's leak scan (which only watches the
+  // virtual server module's values).
+  for (const key of Object.keys(typed.server ?? {})) {
+    const prefix = envPrefixes.find(p => key.startsWith(p));
+    if (prefix) {
+      const bare = key.slice(prefix.length);
+      throw new Error(`[@solidjs/vite-plugin] server env var "${key}" in ${envFile} carries the public ` + `env prefix "${prefix}". Vite exposes every "${prefix}"-prefixed variable to ` + `the browser through import.meta.env no matter which side declares it, so a ` + `\`server\` entry cannot keep it secret. ` + (bare ? `Rename it to "${bare}" (in the schema and in your .env/environment), or ` : `Rename it without the prefix, or `) + `move it to \`client\` if it is public.`);
+    }
+  }
+  return typed;
+}
+
+/**
+ * Generates the ambient `solid-env.d.ts` next to the schema file. The file
+ * is self-contained: it infers each variable's type from the user's own
+ * schema through the Standard Schema `~standard.types.output` phantom, so
+ * any compliant validator library yields full types with no per-library
+ * introspection. Only rewritten when the content actually changes.
+ */
+function generateTypes(schema, envFileAbs) {
+  const dtsPath = path.join(path.dirname(envFileAbs), GENERATED_TYPES_FILE);
+  const importSpec = './' + path.basename(envFileAbs).replace(/\.[mc]?[tj]s$/, '');
+  const field = (side, key) => `    readonly ${JSON.stringify(key)}: __Out<__Schema[${JSON.stringify(side)}][${JSON.stringify(key)}]>;`;
+  const moduleBlock = (id, fields) => [`declare module '${id}' {`, `  type __Schema = typeof import(${JSON.stringify(importSpec)})['default'];`, `  type __Out<T> = T extends { '~standard': { types?: { output: infer O } | undefined } }`, `    ? O`, `    : string;`, `  const env: {`, ...fields, `  };`, `  export { env };`, `  export default env;`, `}`].join('\n');
+  const clientFields = Object.keys(schema.client ?? {}).map(key => field('client', key));
+  const serverFields = [...Object.keys(schema.server ?? {}).map(key => field('server', key)), ...clientFields];
+  const content = `// Generated by @solidjs/vite-plugin (start.env) — do not edit.\n` + `// Regenerated on every dev server and build start from ${path.basename(envFileAbs)}.\n` + `// Keep this file (and the schema) inside your tsconfig "include".\n\n` + moduleBlock(CLIENT_ENV_ID, clientFields) + '\n\n' + moduleBlock(SERVER_ENV_ID, serverFields) + '\n';
+  try {
+    if (fs.existsSync(dtsPath) && fs.readFileSync(dtsPath, 'utf-8') === content) return;
+    fs.writeFileSync(dtsPath, content);
+  } catch (error) {
+    const reason = error instanceof Error ? `: ${error.message}` : '';
+    console.warn(`[@solidjs/vite-plugin] could not write ${GENERATED_TYPES_FILE} next to the env schema` + `${reason} — the virtual env modules stay untyped until it can be written.`);
+  }
+}
+
+/**
+ * Start-mode typed env (the `start.env` option). Returns no plugin when the
+ * feature is off (`env: false`, or nothing to probe); the feature is
+ * start-only by construction — the option lives on `start`, so a bare
+ * `ssr: true` setup has no env layer (documented).
+ */
+function startEnv(option) {
+  if (option === false) return [];
+  let root = process.cwd();
+  let config;
+  let isBuild = false;
+  let isPreview = false;
+  let enabled = false;
+  /** Absolute path of the schema file once resolved. */
+  let envFileAbs = null;
+  /** Root-relative schema path for messages. */
+  let envFile = 'env.ts';
+  let envPromise = null;
+  let devErrorLogged = false;
+  function resolveEnvFile() {
+    if (typeof option === 'string') {
+      const absolute = path.isAbsolute(option) ? option : path.resolve(root, option);
+      if (!fs.existsSync(absolute)) {
+        throw new Error(`[@solidjs/vite-plugin] start.env does not exist: ${option}`);
+      }
+      const relative = path.relative(root, absolute).split(path.sep).join('/');
+      if (relative.startsWith('..')) {
+        throw new Error(`[@solidjs/vite-plugin] start.env must live inside the Vite root: ${option}`);
+      }
+      envFileAbs = absolute;
+      envFile = relative;
+      enabled = true;
+      return;
+    }
+    for (const candidate of ENV_FILE_CANDIDATES) {
+      const absolute = path.resolve(root, candidate);
+      if (fs.existsSync(absolute)) {
+        envFileAbs = absolute;
+        envFile = candidate;
+        enabled = true;
+        return;
+      }
+    }
+    if (option === true) {
+      throw new Error(`[@solidjs/vite-plugin] start.env is enabled but no schema file was found: add ` + `${ENV_FILE_CANDIDATES.join(' or ')} at the project root (default-exporting ` + `{ server, client } maps of Standard Schema validators), or point start.env ` + `at a path.`);
+    }
+  }
+  function envPrefixes() {
+    const prefix = config?.envPrefix ?? 'VITE_';
+    return Array.isArray(prefix) ? prefix : [prefix];
+  }
+  async function loadAndValidate() {
+    const {
+      exported,
+      dependencies
+    } = await (async () => {
+      try {
+        return await importSchemaModule(envFileAbs, root, config.mode);
+      } catch (error) {
+        const reason = error instanceof Error ? `\n\nCause: ${error.message}` : '';
+        throw new Error(`[@solidjs/vite-plugin] could not load the env schema at ${envFile}. It must be a ` + `server-side module default-exporting { server?, client? } maps of Standard ` + `Schema validators.${reason}`);
+      }
+    })();
+    const schema = assertSchemaShape(exported, envFile, envPrefixes());
+    // Types depend only on the schema, not the values: generate before
+    // validating so a missing variable doesn't also break editor types.
+    generateTypes(schema, envFileAbs);
+
+    // Vite's .env story with `loadEnv` merge priority — process.env wins
+    // (CI/pipeline secrets over files), then .env.[mode].local down to .env.
+    // The fold into process.env is what removes the template's classic
+    // `process.env = { ...process.env, ...loadEnv(mode, root, '') }` line:
+    // server code reading process.env directly (db clients, SDKs) sees the
+    // file-loaded vars too, in dev, build, and the client-mode prerender.
+    const envDir = config.envDir === false ? null : config.envDir || root;
+    const folded = foldedKeys();
+    for (const key of folded) delete process.env[key];
+    folded.clear();
+    const fileEnv = envDir ? vite.loadEnv(config.mode, envDir, '') : {};
+    for (const [key, value] of Object.entries(fileEnv)) {
+      if (!(key in process.env)) {
+        process.env[key] = value;
+        folded.add(key);
+      }
+    }
+    const raw = {
+      ...fileEnv,
+      ...stringEntries(process.env)
+    };
+    const issues = [];
+    const all = {};
+    for (const side of ['server', 'client']) {
+      for (const [key, validator] of Object.entries(schema[side] ?? {})) {
+        let result = validator['~standard'].validate(raw[key]);
+        if (result instanceof Promise) result = await result;
+        if (result.issues && result.issues.length) {
+          for (const issue of result.issues) {
+            const at = (issue.path ?? []).map(segment => typeof segment === 'object' && segment !== null && 'key' in segment ? String(segment.key) : String(segment)).join('.');
+            issues.push({
+              key: at ? `${key}.${at}` : key,
+              message: issue.message,
+              side
+            });
+          }
+        } else {
+          all[key] = result.value;
+        }
+      }
+    }
+    if (issues.length) {
+      // Client values are baked at build time, so their failures always
+      // fail hard. Server values are read from process.env at boot: a
+      // build may legitimately run without them (platform-injected vars),
+      // so build-time server failures downgrade to a warning and boot
+      // validation enforces. Dev failures stay hard — dev IS runtime.
+      const clientIssues = issues.filter(issue => issue.side === 'client');
+      if (!isBuild || clientIssues.length) {
+        throw new Error(formatValidationError(!isBuild ? issues : clientIssues, envFile, config.mode));
+      }
+      config.logger.warn(`\n[@solidjs/vite-plugin] server env not valid at build time (deferred to boot ` + `validation — server env is read from process.env at runtime):\n` + issues.map(({
+        key,
+        message
+      }) => `  ⚠ ${key}: ${message}`).join('\n') + '\n');
+    }
+    const client = {};
+    for (const key of Object.keys(schema.client ?? {})) client[key] = all[key];
+    return {
+      schema,
+      all,
+      client,
+      dependencies
+    };
+  }
+  function ensureEnv() {
+    return envPromise ??= loadAndValidate();
+  }
+
+  /**
+   * Whether the current hook runs for a server-destined module graph. The
+   * environment's `consumer` is authoritative (covers workerd and friends
+   * without name lists); classic contexts fall back to the ssr flag.
+   */
+  function isServerContext(ctx, opts) {
+    const consumer = ctx.environment?.config?.consumer;
+    if (consumer) return consumer === 'server';
+    return !!opts?.ssr;
+  }
+  function serverOnlyError(importer) {
+    return `[@solidjs/vite-plugin] ${SERVER_ENV_ID} is server-only and was imported from the ` + `client module graph` + (importer ? ` (by ${importer})` : '') + `. Server env values must never reach the browser bundle: import ` + `${CLIENT_ENV_ID} for the public ${envPrefixes().join('/')}-prefixed vars, or move ` + `this import into a server-only module (a "use server" module, middleware, or the ` + `server entry).`;
+  }
+
+  // Baked-JSON module emission (pattern from @vite-env/core, MIT): the
+  // validated output values serialize as a frozen object literal, so no
+  // validator code exists in the client bundle and tree-shaking sees plain
+  // data. `moduleType` marks the virtual source as plain JS for rolldown
+  // (Vite 8).
+  function envModuleCode(values) {
+    return {
+      code: `// Generated by @solidjs/vite-plugin (start.env)\n` + `export const env = Object.freeze(${JSON.stringify(values)});\n` + `export default env;`,
+      moduleType: 'js'
+    };
+  }
+
+  // The server module is NOT baked: server values are read from
+  // process.env at module init (server boot) and validated through the
+  // user's own schema, imported straight into the server graph (the
+  // validator library is server-only, so shipping it there is fine).
+  // Client (public) values stay baked — that's what the VITE_ prefix
+  // means. Platform-injected vars that don't exist at build time work,
+  // secrets rotate without a rebuild, and no secret value exists in any
+  // dist artifact.
+  function serverEnvModuleCode(loaded) {
+    const serverKeys = Object.keys(loaded.schema.server ?? {});
+    const baked = `const __env = ${JSON.stringify(loaded.client)};`;
+    if (!serverKeys.length) {
+      return {
+        code: `// Generated by @solidjs/vite-plugin (start.env) — server env.\n` + `${baked}\n` + `export const env = Object.freeze(__env);\n` + `export default env;`,
+        moduleType: 'js'
+      };
+    }
+    return {
+      code: [`// Generated by @solidjs/vite-plugin (start.env) — server env.`, `// Server values are read from process.env and validated at boot;`, `// client (public) values are baked at build time.`, `import __schema from ${JSON.stringify(envFileAbs)};`, baked, `const __issues = [];`, `for (const __key of ${JSON.stringify(serverKeys)}) {`, `  let __result = __schema.server[__key]['~standard'].validate(process.env[__key]);`, `  if (__result instanceof Promise) __result = await __result;`, `  if (__result.issues && __result.issues.length) {`, `    for (const __issue of __result.issues) __issues.push('  \\u2717 ' + __key + ': ' + __issue.message);`, `  } else {`, `    __env[__key] = __result.value;`, `  }`, `}`, `if (__issues.length) {`, `  throw new Error(`, `    '[@solidjs/vite-plugin] server env validation failed at boot (' + __issues.length +`, `    ' issue' + (__issues.length === 1 ? '' : 's') + ') \\u2014 schema: ' + ${JSON.stringify(envFile)} +`, `    '\\n\\n' + __issues.join('\\n') +`, `    '\\n\\nServer env is read from process.env at boot, not baked at build time: set the ' +`, `    'variables in the server process environment.'`, `  );`, `}`, `export const env = Object.freeze(__env);`, `export default env;`].join('\n'),
+      moduleType: 'js'
+    };
+  }
+  return [{
+    name: 'solid:start-env',
+    config(userConfig, env) {
+      root = path.resolve(userConfig.root || process.cwd());
+      isPreview = !!env.isPreview;
+      resolveEnvFile();
+      // Preview serves finished artifacts, so no schema loading or
+      // validation happens there — but the built server module reads
+      // process.env at boot, and `vite preview` should smoke-test the
+      // artifact as hands-off as dev runs it: fold the .env files into
+      // process.env (real environment still wins). A production process
+      // brings its own environment instead.
+      if (isPreview && enabled) {
+        const envDirOption = userConfig.envDir;
+        const envDir = envDirOption === false ? null : path.resolve(root, envDirOption || '.');
+        if (envDir) {
+          const folded = foldedKeys();
+          for (const key of folded) delete process.env[key];
+          folded.clear();
+          const fileEnv = vite.loadEnv(userConfig.mode || env.mode, envDir, '');
+          for (const [key, value] of Object.entries(fileEnv)) {
+            if (!(key in process.env)) {
+              process.env[key] = value;
+              folded.add(key);
+            }
+          }
+        }
+      }
+    },
+    configResolved(resolved) {
+      config = resolved;
+      root = resolved.root;
+      isBuild = resolved.command === 'build';
+      if (!enabled || isPreview) return;
+      // Kick validation off eagerly (the fold must precede any server
+      // module execution); buildStart awaits it and owns error routing.
+      ensureEnv().catch(() => {});
+    },
+    async buildStart() {
+      if (!enabled) return;
+      try {
+        await ensureEnv();
+      } catch (error) {
+        // Builds fail with the report; dev logs it once and lets the
+        // virtual modules rethrow on load, which renders Vite's error
+        // overlay (client imports) or the overlay-enabled 500 (SSR).
+        if (isBuild) throw error;
+        if (!devErrorLogged) {
+          devErrorLogged = true;
+          config.logger.error('\n' + (error instanceof Error ? error.message : String(error)) + '\n');
+        }
+      }
+    },
+    resolveId(source, importer, options) {
+      if (!enabled) return null;
+      if (source === CLIENT_ENV_ID) return RESOLVED_CLIENT_ENV_ID;
+      if (source === SERVER_ENV_ID) {
+        // The dep scanner probes client entries' import graphs without
+        // executing them; deny real client-graph imports only (the load
+        // hook double-checks — scanners never load `\0` ids).
+        if (!options?.scan && !isServerContext(this, options)) {
+          this.error(serverOnlyError(importer));
+        }
+        return RESOLVED_SERVER_ENV_ID;
+      }
+      return null;
+    },
+    async load(id, opts) {
+      if (!enabled) return null;
+      if (id !== RESOLVED_CLIENT_ENV_ID && id !== RESOLVED_SERVER_ENV_ID) return null;
+      // Throws the validation report when env is invalid — the dev
+      // overlay / failed build carries the per-key details.
+      const loaded = await ensureEnv();
+      if (id === RESOLVED_SERVER_ENV_ID) {
+        if (!isServerContext(this, opts)) this.error(serverOnlyError());
+        return serverEnvModuleCode(loaded);
+      }
+      return envModuleCode(loaded.client);
+    },
+    configureServer(server) {
+      if (!enabled) return;
+      const envDir = config.envDir === false ? null : config.envDir || root;
+      // Explicit file list (no globs — chokidar 4 dropped them): the four
+      // .env variants Vite consults for this mode, the schema module, and
+      // whatever it transitively loaded.
+      const envFiles = envDir ? ['.env', '.env.local', `.env.${config.mode}`, `.env.${config.mode}.local`].map(file => path.join(envDir, file)) : [];
+      const watched = new Set([...envFiles, envFileAbs]);
+      server.watcher.add([...watched]);
+      ensureEnv().then(({
+        dependencies
+      }) => {
+        for (const dep of dependencies) watched.add(dep);
+        server.watcher.add(dependencies);
+      }).catch(() => {});
+
+      // Live revalidation (flow from @vite-env/core, MIT): reload sources,
+      // rerun the schema, invalidate both virtual modules in every
+      // environment, and full-reload — on failure the reload makes the
+      // client re-import the virtual module, whose load() now throws the
+      // fresh report into the error overlay.
+      let debounce;
+      const onFileEvent = file => {
+        if (!watched.has(file)) return;
+        clearTimeout(debounce);
+        debounce = setTimeout(async () => {
+          envPromise = null;
+          devErrorLogged = false;
+          let failed = false;
+          try {
+            const {
+              dependencies
+            } = await ensureEnv();
+            for (const dep of dependencies) watched.add(dep);
+            server.watcher.add(dependencies);
+          } catch (error) {
+            failed = true;
+            devErrorLogged = true;
+            config.logger.error('\n' + (error instanceof Error ? error.message : String(error)) + '\n');
+          }
+          let invalidated = false;
+          for (const environment of Object.values(server.environments ?? {})) {
+            const graph = environment.moduleGraph;
+            if (!graph) continue;
+            for (const id of [RESOLVED_CLIENT_ENV_ID, RESOLVED_SERVER_ENV_ID]) {
+              const mod = graph.getModuleById(id);
+              if (mod) {
+                graph.invalidateModule(mod);
+                invalidated = true;
+              }
+            }
+          }
+          if (invalidated) {
+            const hot = server.hot ?? server.ws;
+            hot?.send({
+              type: 'full-reload'
+            });
+          }
+          if (!failed) {
+            config.logger.info(`[@solidjs/vite-plugin] env revalidated (${envFile})`);
+          }
+        }, 100);
+      };
+      server.watcher.on('change', onFileEvent);
+      server.watcher.on('add', onFileEvent);
+      server.watcher.on('unlink', onFileEvent);
+    },
+    // Leak scan (heuristics from @vite-env/core, MIT): a server var's
+    // *value* appearing as a quoted string literal in a client chunk means
+    // something inlined it (an env.ts import from shared code, a define,
+    // a copy-paste). Values under 8 chars skip (too collision-prone), as
+    // do values shared with a client var and pure-vendor chunks.
+    async generateBundle(_options, bundle) {
+      if (!enabled || !isBuild || isServerContext(this, {
+        ssr: !!config.build.ssr
+      })) return;
+      const loaded = await ensureEnv().catch(() => null);
+      if (!loaded) return;
+      const clientValues = new Set(Object.values(loaded.client));
+      const secrets = Object.entries(loaded.all).filter(entry => !(entry[0] in loaded.client) && typeof entry[1] === 'string' && entry[1].length >= 8 && !clientValues.has(entry[1]));
+      if (!secrets.length) return;
+      const leaks = [];
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type !== 'chunk' || !chunk.code) continue;
+        const moduleIds = chunk.moduleIds ?? [];
+        if (moduleIds.length > 0 && moduleIds.every(id => /[\\/]node_modules[\\/]/.test(id))) continue;
+        for (const [key, value] of secrets) {
+          const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+          if (new RegExp(`(["'\`])${escaped}\\1`).test(chunk.code)) {
+            leaks.push(`${key} in ${fileName}`);
+          }
+        }
+      }
+      if (leaks.length) {
+        this.error(`[@solidjs/vite-plugin] server env values leaked into client chunks:\n` + leaks.map(leak => `  ✗ ${leak}`).join('\n') + `\n\nServer env values belong to the server process only (they are not even ` + `baked into the server bundle). Check for hand-inlined values and imports of ` + `the env schema module from client code, and use ${SERVER_ENV_ID} from ` + `server-only modules instead.`);
+      }
+    }
+  }];
+}
+
+const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+
+/**
+ * The `lazy()` module-URL placeholder contract, shared with the native
+ * compiler's `transformLazy` pass: `lazy(() => import("spec"))` calls gain a
+ * second string-literal argument of the form
+ * `"__SOLID_LAZY_MODULE__:" + spec`, which `resolveLazyModuleUrls` swaps for
+ * the project-relative resolved module path. The prefix and shape are FROZEN
+ * — the emitting side lives in @dom-expressions/compiler and must match.
+ */
+const LAZY_PLACEHOLDER_PREFIX = '__SOLID_LAZY_MODULE__:';
+
+/**
+ * The HMR runtime: the dev-only `solid-js/refresh` core entry. Refresh
+ * wrappers are compiled by the native `transformRefresh` pass in every mode
+ * and import the runtime through normal module resolution (the legacy
+ * solid-refresh package — whose runtime carries a known Solid 2.0 HMR bug,
+ * solid-refresh#85 — is no longer used at all).
+ */
+const REFRESH_RUNTIME_SOURCE = 'solid-js/refresh';
+const viteVersionMajor = +vite.version.split('.')[0];
+const isVite8 = viteVersionMajor >= 8;
+const VIRTUAL_MANIFEST_ID = 'virtual:solid-manifest';
+const RESOLVED_VIRTUAL_MANIFEST_ID = '\0' + VIRTUAL_MANIFEST_ID;
+
+// In dev the virtual manifest exports a `{ resolve, resolveSync }` resolver:
+// lazy modules resolve to their dev URL plus transitively imported CSS as
+// inline-style descriptors collected from the live module graph. The resolver
+// itself lives plugin-side (it closes over the dev server) and is reached
+// through a global registry; isolated module runners that don't share
+// globals (nitro's dev worker, workerd) fall back to fetching the dev
+// server's bridge endpoint, whose URL is baked in at generation time
+// (`bridgeUrl` — null outside a live dev server, e.g. the manifest-less SSR
+// build fallback, where js-only resolution remains). Bridge failures log
+// loudly and resolve to null so the runtime's own no-assets warning stays
+// the final catch-all.
+//
+// The generated `moduleUrl` mirrors `devModuleUrl` (src/dev-manifest.ts) —
+// base-prefixed root-relative URLs, `/@fs/` for root-external keys — for the
+// degraded paths that can't reach the plugin-side resolver (no registry and
+// no bridge, or a resolveSync call before the bridge cache warms). Keep the
+// two in sync.
+const devManifestCode = (root, base, bridgeUrl) => `const registry = globalThis[Symbol.for(${JSON.stringify(DEV_MANIFEST_REGISTRY_KEY)})];
+const projectRoot = ${JSON.stringify(root.split(path.sep).join('/'))};
+const base = ${JSON.stringify(base.startsWith('/') ? base.replace(/\/$/, '') : '')};
+function moduleUrl(key) {
+  const queryIndex = key.indexOf("?");
+  const file = queryIndex === -1 ? key : key.slice(0, queryIndex);
+  const query = queryIndex === -1 ? "" : key.slice(queryIndex);
+  if (file.slice(0, 2) !== "..") return base + "/" + key;
+  const segments = (projectRoot + "/" + file).split("/");
+  const resolved = [];
+  for (const segment of segments) {
+    if (segment === "..") resolved.pop();
+    else if (segment && segment !== ".") resolved.push(segment);
+  }
+  return base + "/@fs/" + resolved.join("/") + query;
+}
+const jsOnly = key => ({ js: [moduleUrl(key)], css: [] });
+const bridgeUrl = ${JSON.stringify(bridgeUrl)};
+function createBridgeResolver() {
+  // Convergence cache, mirroring the in-process resolver: server-side lazy()
+  // re-requests assets on every retry of a suspended render pass, and only a
+  // synchronous answer lets the pass converge (a fresh promise per call
+  // suspends every retry anew — nested routes then loop until the render
+  // stack overflows). Cached entries can go stale after a CSS edit (no
+  // watcher reaches this side of the bridge); the HMR client replaces SSR'd
+  // dev styles on load, so staleness self-heals at hydration. Only successful
+  // answers are cached: a null (bridge failure) must stay retryable, or one
+  // transient miss would strip the module's client assets — silently — for
+  // the rest of the dev session. In-flight dedupe still gives retries of the
+  // same pass a stable promise, so convergence holds either way.
+  const cache = new Map();
+  const inFlight = new Map();
+  return {
+    resolve(key) {
+      const cached = cache.get(key);
+      if (cached) return cached;
+      let request = inFlight.get(key);
+      if (!request) {
+        request = fetchAssets(key).then(
+          (assets) => {
+            if (assets) cache.set(key, assets);
+            inFlight.delete(key);
+            return assets;
+          },
+          (error) => {
+            inFlight.delete(key);
+            throw error;
+          },
+        );
+        inFlight.set(key, request);
+      }
+      return request;
+    },
+    resolveSync: (key) => cache.get(key) || jsOnly(key),
+  };
+}
+async function fetchAssets(key) {
+  const url = new URL(bridgeUrl);
+  url.searchParams.set("key", key);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    console.error(
+      '[@solidjs/vite-plugin] Dev manifest bridge request failed for module key "' + key +
+        '" (' + url.href + '): ' + ((error && error.message) || error) +
+        ". SSR will render without this module's client assets, so its hydration preload entry will be missing.",
+    );
+    return null;
+  }
+  if (!response.ok) {
+    // A silent null here strips the module's client assets from the
+    // SSR'd hydration asset map and hydration fails much later with a
+    // cryptic client-side error — report the miss where it happens.
+    console.error(
+      '[@solidjs/vite-plugin] Dev manifest bridge request failed with status ' + response.status +
+        ' for module key "' + key + '" (' + url.href +
+        "). SSR will render without this module's client assets, so its hydration preload entry will be missing.",
+    );
+    return null;
+  }
+  return response.json();
+}
+export default (registry && registry[${JSON.stringify(root)}]) ||
+  (bridgeUrl ? createBridgeResolver() : { resolve: jsOnly, resolveSync: jsOnly });`;
+const SOLID_BUILT_INS = ['For', 'Show', 'Switch', 'Match', 'Loading', 'Reveal', 'Portal', 'Repeat', 'Dynamic', 'Errored'];
+
+/** Possible options for the extensions property */
+
+let nativeCompilerPromise;
+async function loadNativeCompiler() {
+  try {
+    return await (nativeCompilerPromise ??= import('@dom-expressions/compiler'));
+  } catch (error) {
+    nativeCompilerPromise = undefined;
+    const reason = error instanceof Error ? `\n\nCause: ${error.message}` : '';
+    throw new Error('@solidjs/vite-plugin: failed to load @dom-expressions/compiler, which is required ' + 'in every mode (it drives the lazy, refresh, and server-function transforms; ' + 'compiler: "babel" only switches the JSX transform). Your platform should get ' + 'a prebuilt native binary or the @dom-expressions/compiler-wasm32-wasi fallback ' + '— check that optional dependencies were installed.' + reason);
+  }
+}
+
+/** Configuration options for @solidjs/vite-plugin. */
+
+/** Options for the solid-refresh HMR transform (dev only). */
+
+function getExtension(filename) {
+  const index = filename.lastIndexOf('.');
+  return index < 0 ? '' : filename.substring(index).replace(/\?.+$/, '');
+}
+function containsSolidField(fields) {
+  const keys = Object.keys(fields);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key === 'solid') return true;
+    if (typeof fields[key] === 'object' && fields[key] != null && containsSolidField(fields[key])) return true;
+  }
+  return false;
+}
+function getJestDomExport(setupFiles) {
+  return setupFiles?.some(path => /jest-dom/.test(path)) ? undefined : ['@testing-library/jest-dom/vitest', '@testing-library/jest-dom/extend-expect'].find(path => {
+    try {
+      require$1.resolve(path);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function getSolidOptions(options, isSsr, dev, isTestMode = false) {
+  let solidOptions;
+  if (isTestMode) {
+    // Vitest compiles with the client posture regardless of the app's `ssr`
+    // flag: component tests exercise DOM code and nothing hydrates in a
+    // test, so hydratable output would look for markers that aren't there.
+    // `generate` still follows the transform's own ssr flag, so explicit
+    // node-environment tests (renderToString) keep their server codegen.
+    solidOptions = {
+      generate: isSsr ? 'ssr' : 'dom',
+      hydratable: false
+    };
+  } else if (options.start && !options.ssr) {
+    // Client start mode: client code compiles exactly like a plain SPA
+    // (dom, non-hydratable — nothing hydrates); only the document shell
+    // render goes through the SSR transforms, also non-hydratable since
+    // the shell is inert HTML the client never claims.
+    solidOptions = {
+      generate: isSsr ? 'ssr' : 'dom',
+      hydratable: false
+    };
+  } else if (options.ssr) {
+    if (isSsr) {
+      solidOptions = {
+        generate: 'ssr',
+        hydratable: true
+      };
+    } else {
+      solidOptions = {
+        generate: 'dom',
+        hydratable: true
+      };
+    }
+  } else {
+    solidOptions = {
+      generate: 'dom',
+      hydratable: false
+    };
+  }
+  return {
+    moduleName: '@solidjs/web',
+    builtIns: SOLID_BUILT_INS,
+    contextToCustomElements: true,
+    wrapConditionals: true,
+    ...solidOptions,
+    dev,
+    ...(options.solid || {})
+  };
+}
+async function getBabelUserOptions(options, source, id, isSsr) {
+  if (!options.babel) return {};
+  if (typeof options.babel !== 'function') return options.babel;
+  const babelOptions = options.babel(source, id, isSsr);
+  return babelOptions instanceof Promise ? await babelOptions : babelOptions;
+}
+function normalizeSourceMap(map) {
+  if (typeof map === 'string') return JSON.parse(map);
+  return map || null;
+}
+/**
+ * Merges the sourcemaps of sequential whole-file transforms (given in
+ * application order, earliest first) into one map tracing back to the
+ * original source.
+ */
+function combineSourcemaps(maps) {
+  const chain = maps.filter(map => !!map);
+  if (chain.length === 0) return null;
+  if (chain.length === 1) return normalizeSourceMap(chain[0]);
+  // remapping expects most-recent-first.
+  return JSON.parse(remapping(chain.reverse(), () => null).toString());
+}
+
+/**
+ * Chunks emitted for lazy() targets are marked `isEntry` by Rollup even
+ * though they are semantically dynamic entries. Reclassify any entry that is
+ * dynamically imported by another chunk so the runtime's entry-asset
+ * detection (which keys off `isEntry`) can't pick a lazy facade instead of
+ * the real client entry. Works on both the Vite manifest.json shape and the
+ * raw Rollup output bundle — both key entries by name and expose
+ * `dynamicImports` / `isEntry` with the same meaning.
+ */
+function normalizeEmittedLazyEntries(manifest) {
+  const dynamicKeys = new Set();
+  for (const key in manifest) {
+    const imports = manifest[key].dynamicImports;
+    if (imports) for (const dep of imports) dynamicKeys.add(dep);
+  }
+  for (const key of dynamicKeys) {
+    const entry = manifest[key];
+    if (entry && entry.isEntry) {
+      entry.isEntry = false;
+      entry.isDynamicEntry = true;
+    }
+  }
+}
+function solidPlugin(options = {}) {
+  if (typeof options.ssr === 'object') {
+    throw new Error('[@solidjs/vite-plugin] `ssr` now only accepts a boolean ("is the app server-rendered"); ' + 'move start-mode options to `start: {}` and set `ssr: true`. Example: ' + '`solid({ ssr: { document: … } })` becomes `solid({ start: { document: … }, ssr: true })`.');
+  }
+  // Recreated in configResolved: relative include/exclude patterns must
+  // resolve against the Vite root, not process.cwd() — running `vite` from
+  // outside the project would otherwise change what the filter matches.
+  let filter = vite.createFilter(options.include, options.exclude);
+  const serverComponents = typeof options.serverFunctions === 'object' && !!options.serverFunctions.components;
+  // `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;
+  // `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;
+  let needHmr = false;
+  let replaceDev = false;
+  // The live dev server, kept so the dev manifest module can bake the bridge
+  // endpoint URL in when its code is generated (see devManifestBridgeUrl).
+  let devServer = null;
+  let projectRoot = process.cwd();
+  let isTestMode = false;
+  let serverTestPosture = false;
+  let isBuild = false;
+  let isSsrBuild = false;
+  let base = '/';
+  let clientOutDir = null;
+  let solidPkgsConfig;
+
+  // The client build's manifest, read back by SSR builds. In builder-mode
+  // (single process, e.g. SolidStart's nitro plugin) the client build runs
+  // first and generateBundle records its actual outDir — authoritative, since
+  // such setups relocate it. Two-invocation builds (`vite build --outDir
+  // dist/client` then `vite build --ssr`) run in separate processes, so the
+  // SSR process falls back to the `dist/client` convention.
+  function clientManifestPath() {
+    for (const dir of [clientOutDir, 'dist/client']) {
+      if (!dir) continue;
+      const manifestPath = path.resolve(projectRoot, dir, '.vite/manifest.json');
+      if (fs.existsSync(manifestPath)) return manifestPath;
+    }
+    return null;
+  }
+
+  // Dynamically imported project modules in the client build. Each is
+  // emitted as an explicit chunk so it always gets its own manifest entry
+  // keyed by source path — even when manualChunks or dual static/dynamic
+  // imports would otherwise fold it facade-less into a shared chunk (which
+  // would break resolveAssets lookups and hydration module preloading).
+  // Driven from moduleParsed so it covers every lazy() target, including
+  // import.meta.glob entries that never pass through the moduleUrl transform.
+  const emittedLazyChunks = new Set();
+  // Keep the emitted references because a lazy module's importer may be
+  // removed from the final bundle, leaving no dynamic-import edge to identify
+  // its facade chunk during generateBundle.
+  const emittedLazyChunkRefs = [];
+
+  // Whether the current hook invocation belongs to a client (browser) build.
+  // Builder-mode builds (e.g. SolidStart's nitro plugin) run the client and
+  // ssr environments through one Vite process with shared plugins, so the
+  // process-wide isSsrBuild flag from configResolved can't tell them apart —
+  // the per-environment consumer can. Classic two-invocation builds
+  // (`vite build` / `vite build --ssr`) fall back to the flag.
+  function isClientBuild(ctx) {
+    const consumer = ctx.environment?.config?.consumer;
+    if (consumer) return consumer === 'client';
+    return !isSsrBuild;
+  }
+
+  /**
+   * Replaces lazy() moduleUrl placeholders injected by the babel plugin with
+   * project-relative module paths resolved through Vite's resolver.
+   */
+  async function resolveLazyModuleUrls(ctx, code, importer) {
+    const placeholderRe = new RegExp('"' + LAZY_PLACEHOLDER_PREFIX + '([^"]+)"', 'g');
+    let match;
+    const resolutions = [];
+    while ((match = placeholderRe.exec(code)) !== null) {
+      const specifier = match[1];
+      const resolved = await ctx.resolve(specifier, importer);
+      if (resolved) {
+        // The query is part of the module identity: Rollup keys the facade
+        // chunk (and thus the Vite manifest entry) by the queried module id,
+        // and in dev the queried URL can serve different plugin output than
+        // the bare one — stripping it here would break both lookups.
+        const queryIndex = resolved.id.indexOf('?');
+        const file = queryIndex === -1 ? resolved.id : resolved.id.slice(0, queryIndex);
+        const query = queryIndex === -1 ? '' : resolved.id.slice(queryIndex);
+        const relativeId = path.relative(projectRoot, file).split(path.sep).join('/') + query;
+        resolutions.push({
+          placeholder: match[0],
+          resolved: '"' + relativeId + '"'
+        });
+      }
+    }
+    for (const {
+      placeholder,
+      resolved
+    } of resolutions) {
+      code = code.replace(placeholder, resolved);
+    }
+    return code;
+  }
+
+  /**
+   * SSR transforms append a `$$moduleUrl` export carrying the module's
+   * client-manifest key (project-relative source path, module query
+   * included — a queried module is its own identity, with its own facade
+   * chunk and manifest entry). Server-side `lazy()` reads it off the
+   * resolved module when the callsite has no static import specifier to
+   * transform — e.g. `lazy` over an `import.meta.glob` entry — so asset
+   * resolution and hydration preloading still work. Client builds are
+   * untouched.
+   */
+  function injectSsrModuleId(code, id, isSsr) {
+    if (!isSsr || /node_modules/.test(id) || code.includes('$$moduleUrl')) return code;
+    const queryIndex = id.indexOf('?');
+    const file = queryIndex === -1 ? id : id.slice(0, queryIndex);
+    const query = queryIndex === -1 ? '' : id.slice(queryIndex);
+    const relativeId = path.relative(projectRoot, file).split(path.sep).join('/') + query;
+    return code + `\nexport const $$moduleUrl = ${JSON.stringify(relativeId)};\n`;
+  }
+  const mainPlugin = {
+    name: 'solid',
+    enforce: 'pre',
+    async config(userConfig, {
+      command
+    }) {
+      // We inject the dev mode only if the user explicitly wants it or if we are in dev (serve) mode
+      replaceDev = options.dev === true || options.dev !== false && command === 'serve';
+      projectRoot = userConfig.root || projectRoot;
+      isTestMode = userConfig.mode === 'test';
+      // Per-vitest-project posture: the client posture (browser conditions,
+      // dom codegen, jsdom default) is right for DOM component tests but
+      // wrong for server-runtime unit tests. A project that explicitly opts
+      // into a server runtime — `test: { environment: 'node' }` (or
+      // 'edge-runtime') — gets the server posture end to end: no browser
+      // condition injection, so the framework resolves its real server
+      // build (isServer true) with no inline/alias workarounds. DOM
+      // environments (the jsdom default, happy-dom, browser mode) keep the
+      // client posture. Each vitest project resolves its own config, so the
+      // hooks below see the posture of the project they serve.
+      serverTestPosture = isTestMode && (userConfig.test?.environment === 'node' || userConfig.test?.environment === 'edge-runtime');
+      solidPkgsConfig = await vitefu.crawlFrameworkPkgs({
+        viteUserConfig: userConfig,
+        root: projectRoot || process.cwd(),
+        isBuild: command === 'build',
+        isFrameworkPkgByJson(pkgJson) {
+          return containsSolidField(pkgJson.exports || {});
+        }
+      });
+
+      // fix for bundling dev in production
+      const nestedDeps = replaceDev ? ['solid-js', '@solidjs/web'] : [];
+      const userTest = userConfig.test ?? {};
+      const test = {};
+      if (userConfig.mode === 'test') {
+        // to simplify the processing of the config, we normalize the setupFiles to an array
+        const userSetupFiles = typeof userTest.setupFiles === 'string' ? [userTest.setupFiles] : userTest.setupFiles || [];
+
+        // Regardless of the app's `ssr` flag: tests run with the client
+        // posture (DOM component tests are the norm), so the default test
+        // environment is a DOM. Node-environment tests opt in explicitly.
+        // Browser-mode projects get the real browser DOM, so don't default
+        // them to jsdom — vitest probes for the environment's package at
+        // startup and fails the run if jsdom isn't installed. They fall
+        // back to vitest's own node default (no package probe).
+        if (!userTest.environment && !userTest.browser?.enabled) {
+          test.environment = 'jsdom';
+        }
+        if (serverTestPosture) {
+          // The worker pool is shared across the whole vitest workspace and
+          // imports externalized deps natively with `--conditions` derived
+          // from the ROOT config — which carries the client posture's
+          // 'browser'. Inline the framework so every resolution goes through
+          // THIS project's (server) conditions instead: one server-build
+          // instance end to end (request-event storage included).
+          if (!userTest.server?.deps?.inline) {
+            test.server = {
+              deps: {
+                inline: [/solid-js/, /@solidjs[+/]web/]
+              }
+            };
+          }
+        } else if (!userTest.server?.deps?.external?.find(item => /solid-js/.test(item.toString()))) {
+          test.server = {
+            deps: {
+              external: [/solid-js/]
+            }
+          };
+        }
+        // jest-dom's DOM matchers have no place in a server-posture project;
+        // vitest browser mode already has bundled jest-dom assertions
+        // https://main.vitest.dev/guide/browser/assertion-api.html#assertion-api
+        if (!userTest.browser?.enabled && !serverTestPosture) {
+          const jestDomImport = getJestDomExport(userSetupFiles);
+          if (jestDomImport) {
+            test.setupFiles = [jestDomImport];
+          }
+        }
+      }
+      return {
+        /**
+         * We only need esbuild on .ts or .js files.
+         * .tsx & .jsx files are handled by us
+         */
+        // esbuild: { include: /\.ts$/ },
+        // resolve.conditions is handled per-environment in configEnvironment.
+        resolve: {
+          dedupe: nestedDeps
+        },
+        optimizeDeps: {
+          include: [...nestedDeps,
+          // Dev refresh wrappers import the solid-js/refresh runtime in
+          // every mode; pre-bundle it up front so its discovery doesn't
+          // trigger a re-optimize + full reload on first use.
+          ...(command === 'serve' && options.hot !== false && !options.refresh?.disabled ? [REFRESH_RUNTIME_SOURCE] : []),
+          // The server-components client runtime is imported by the
+          // (virtual) client entry, and compiled function references
+          // import the server-function client runtime; pre-bundle both up
+          // front — in one optimizer pass — so a mid-session discovery
+          // can't trigger a re-optimize + full reload, and both entries
+          // share one instance of the transport config module (the
+          // 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. Tell it to preserve JSX as-is since
+          // this plugin handles JSX transformation via babel-preset-solid.
+          ...(isVite8 ? {
+            rolldownOptions: {
+              transform: {
+                jsx: 'preserve'
+              }
+            }
+          } : {})
+        },
+        ...(Object.keys(test).length ? {
+          test
+        } : {})
+      };
+    },
+    // @ts-ignore This hook only works in Vite 6
+    async 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 {
+          config.resolve.conditions = [...defaultServerConditions];
+        }
+      }
+      config.resolve.conditions = ['solid', ...(replaceDev ? ['development'] : []),
+      // Tests resolve the browser builds even when the app is
+      // server-rendered — the client posture applies to the whole test
+      // pipeline, not just the codegen. Projects that explicitly opt into
+      // a server runtime (`test.environment: 'node'` / 'edge-runtime')
+      // keep the default server conditions instead, so the framework's
+      // real server build resolves (isServer true).
+      ...(isTestMode && !serverTestPosture && !opts.isSsrTargetWebworker ? ['browser'] : []), ...config.resolve.conditions];
+
+      // Set resolve.noExternal and resolve.external for the SSR environment.
+      // Only set resolve.external if noExternal is not true (to avoid conflicts with plugins like Cloudflare)
+      if (name === 'ssr' && solidPkgsConfig) {
+        if (config.resolve.noExternal !== true) {
+          config.resolve.noExternal = [...(Array.isArray(config.resolve.noExternal) ? config.resolve.noExternal : []), ...solidPkgsConfig.ssr.noExternal];
+          config.resolve.external = [...(Array.isArray(config.resolve.external) ? config.resolve.external : []), ...solidPkgsConfig.ssr.external];
+        }
+      }
+    },
+    configResolved(config) {
+      isBuild = config.command === 'build';
+      isSsrBuild = !!config.build.ssr;
+      base = config.base;
+      projectRoot = config.root;
+      filter = vite.createFilter(options.include, options.exclude, {
+        resolve: 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.');
+      }
+      needHmr = config.command === 'serve' && config.mode !== 'production' && options.hot !== false && !options.refresh?.disabled;
+    },
+    configureServer(server) {
+      devServer = server;
+      // Dev asset resolution for SSR: the virtual manifest module (evaluated
+      // in the SSR environment) picks this resolver up through the global
+      // registry keyed by project root — or, from isolated module runners
+      // 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));
+        installDevManifestBridge(server);
+      }
+      if (!needHmr) return;
+      // When a module has a syntax error, Vite sends the error overlay via
+      // WebSocket but the failed import triggers invalidation in solid-refresh.
+      // This propagates up to @refresh reload boundaries (e.g. document-level
+      // App components in SSR), causing a full-reload that overrides the overlay.
+      // We suppress update/full-reload messages that immediately follow an error.
+      const hot = server.hot ?? server.ws;
+      if (!hot) return;
+      let lastErrorTime = 0;
+      const origSend = hot.send.bind(hot);
+      hot.send = function (...args) {
+        const payload = args[0];
+        if (typeof payload === 'object' && payload) {
+          if (payload.type === 'error') {
+            lastErrorTime = Date.now();
+          } else if (lastErrorTime && (payload.type === 'full-reload' || payload.type === 'update')) {
+            if (Date.now() - lastErrorTime < 200) return;
+            lastErrorTime = 0;
+          }
+        }
+        return origSend(...args);
+      };
+    },
+    hotUpdate({
+      modules
+    }) {
+      // solid-refresh only injects HMR boundaries into client modules, so
+      // non-client environments have no accept handlers. Without this, Vite
+      // would see no boundaries and send full-reload messages that race with
+      // client-side HMR updates. Provider-owned (non-runnable) environments
+      // fall through instead: their plugin needs the real module list to
+      // invalidate its remote runner, and its channel never reaches the
+      // browser websocket.
+      if (this.environment.name !== 'client' && isRunnableEnvironment(this.environment)) {
+        // Returning [] also suppresses the signal environment-runner based
+        // servers (e.g. nitro's dev worker) rely on to re-evaluate modules,
+        // leaving SSR stale until a manual restart. Send the reload on this
+        // environment's own channel — for runner-based environments that is
+        // the runner, for the default ssr environment a no-op, and never the
+        // browser websocket, so client HMR stays free of full-reload races.
+        if (modules.length > 0) {
+          this.environment.hot.send({
+            type: 'full-reload'
+          });
+        }
+        return [];
+      }
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_MANIFEST_ID) return RESOLVED_VIRTUAL_MANIFEST_ID;
+    },
+    moduleParsed(info) {
+      // SSR-mode client builds only: give every dynamically imported project
+      // module its own facade chunk (exports-only preserves `default`
+      // re-exports) so it keeps a manifest entry keyed by its source path
+      // even when chunk grouping would otherwise absorb it. Plain SPA builds
+      // have no manifest lookups to protect.
+      if (!isBuild || !options.ssr || !isClientBuild(this)) return;
+      for (const depId of info.dynamicallyImportedIds || []) {
+        const cleanId = depId.split('?')[0];
+        if (/node_modules/.test(cleanId) || cleanId.startsWith('\0')) continue;
+        if (!/\.[mc]?[tj]sx?$/i.test(cleanId)) continue;
+        if (emittedLazyChunks.has(depId)) continue;
+        emittedLazyChunks.add(depId);
+        emittedLazyChunkRefs.push(this.emitFile({
+          type: 'chunk',
+          id: depId,
+          preserveSignature: 'exports-only'
+        }));
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_MANIFEST_ID) {
+        if (!isBuild) {
+          return devManifestCode(projectRoot, base, devServer ? devManifestBridgeUrl(devServer) : null);
+        }
+        const manifestPath = clientManifestPath();
+        if (manifestPath) {
+          const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+          normalizeEmittedLazyEntries(manifest);
+          manifest._base = base;
+          return `export default ${JSON.stringify(manifest)};`;
+        }
+        // SSR build before the client build produced a manifest: bake in the
+        // dev-shaped fallback (registry miss degrades to js-only resolution).
+        return devManifestCode(projectRoot, base, null);
+      }
+    },
+    generateBundle(outputOptions, bundle) {
+      if (!isBuild || !isClientBuild(this)) return;
+      clientOutDir = outputOptions.dir ?? null;
+      // Reclassify emitted lazy facade chunks in the raw bundle (not just the
+      // serialized manifest read back later) so downstream plugins inspecting
+      // the bundle don't mistake them for application entries. Must precede
+      // the client asset map build, which keys off dynamic entries.
+      if (options.ssr) {
+        for (const ref of emittedLazyChunkRefs) {
+          let fileName;
+          try {
+            fileName = this.getFileName(ref);
+          } catch {
+            // Ignore references retained from a previous watch build.
+            continue;
+          }
+          const chunk = bundle[fileName];
+          if (!chunk || chunk.type !== 'chunk') continue;
+          chunk.isEntry = false;
+          chunk.isDynamicEntry = true;
+        }
+        normalizeEmittedLazyEntries(bundle);
+      }
+    },
+    async transform(source, id, transformOptions) {
+      const isSsr = transformOptions && transformOptions.ssr;
+      const currentFileExtension = getExtension(id);
+      const extensionsToWatch = options.extensions || [];
+      const allExtensions = extensionsToWatch.map(extension =>
+      // An extension can be a string or a tuple [extension, options]
+      typeof extension === 'string' ? extension : extension[0]);
+      if (!filter(id)) {
+        return null;
+      }
+
+      // The queried id is the module's real identity (facade chunk /
+      // manifest key / dev URL); keep it for the `$$moduleUrl` injection
+      // while the transform pipeline below works on the clean file path.
+      const moduleId = id;
+      id = id.replace(/\?.*$/, '');
+      if (!(/\.[mc]?[tj]sx$/i.test(id) || allExtensions.includes(currentFileExtension))) {
+        return null;
+      }
+      const inNodeModules = /node_modules/.test(id);
+      const solidOptions = getSolidOptions(options, !!isSsr, replaceDev, isTestMode);
+
+      // We need to know if the current file extension has a typescript options tied to it
+      const shouldBeProcessedWithTypescript = /\.[mc]?tsx$/i.test(id) || extensionsToWatch.some(extension => {
+        if (typeof extension === 'string') {
+          return extension.includes('tsx');
+        }
+        const [extensionName, extensionOptions] = extension;
+        if (extensionName !== currentFileExtension) return false;
+        return extensionOptions.typescript;
+      });
+      const plugins = ['jsx', 'decorators'];
+      if (shouldBeProcessedWithTypescript) {
+        plugins.push('typescript');
+      }
+      const needRefresh = needHmr && !isSsr && !inNodeModules;
+      const babelUserOptions = await getBabelUserOptions(options, source, id, !!isSsr);
+
+      // The native compiler picks its parser dialect from the file
+      // extension; custom extensions registered through `options.extensions`
+      // are unknown to it, so borrow a standard one matching the configured
+      // TypeScript-ness.
+      const nativeFilename = /\.(?:[mc]?[jt]s|[jt]sx)$/i.test(id) ? id : id + (shouldBeProcessedWithTypescript ? '.tsx' : '.jsx');
+
+      // Shared native prelude for every mode: the lazy() module-URL pass,
+      // then (dev/client/non-node_modules) the solid-refresh HMR pass, both
+      // operating on pre-JSX source. Only the JSX transform itself differs
+      // between compiler backends. Sourcemaps are collected in application
+      // order and merged at the end.
+      const compiler = await loadNativeCompiler();
+      let code = source;
+      const maps = [];
+      const lazyResult = await compiler.transformLazyAsync(code, {
+        filename: nativeFilename,
+        sourceMap: true
+      });
+      code = lazyResult.code;
+      maps.push(lazyResult.map);
+      if (needRefresh) {
+        const refreshResult = await compiler.transformRefreshAsync(code, {
+          filename: nativeFilename,
+          bundler: 'vite',
+          fixRender: true,
+          // The napi validator rejects explicit undefined; omit to get the
+          // pass's default (true).
+          ...(typeof options.refresh?.granular === 'boolean' ? {
+            granular: options.refresh.granular
+          } : {}),
+          jsx: false,
+          importSource: REFRESH_RUNTIME_SOURCE,
+          sourceMap: true
+        });
+        code = refreshResult.code;
+        maps.push(refreshResult.map);
+      }
+      const babelBaseOptions = {
+        root: projectRoot,
+        filename: id,
+        sourceFileName: id,
+        ast: false,
+        sourceMaps: true,
+        configFile: false,
+        babelrc: false,
+        parserOpts: {
+          plugins
+        }
+      };
+      if (options.compiler !== 'babel') {
+        if (options.babel) {
+          // Custom babel options reintroduce a Babel support pass hosting
+          // only the user's plugins, ahead of the native JSX transform.
+          const supportOptions = mergeAnything.mergeAndConcat(babelUserOptions, babelBaseOptions);
+          const supportResult = await babel__namespace.transformAsync(code, supportOptions);
+          if (!supportResult) {
+            return undefined;
+          }
+          code = supportResult.code || '';
+          maps.push(supportResult.map);
+        }
+        const result = await compiler.transformAsync(code, {
+          ...solidOptions,
+          filename: nativeFilename,
+          sourceMap: true
+        });
+        maps.push(result.map);
+        const finalCode = injectSsrModuleId(await resolveLazyModuleUrls(this, result.code || '', id), moduleId, !!isSsr);
+        return {
+          code: finalCode,
+          map: combineSourcemaps(maps)
+        };
+      }
+
+      // Babel JSX backend: one babel.transformAsync hosting the user's
+      // options plus babel-preset-solid.
+      const babelOptions = mergeAnything.mergeAndConcat(babelUserOptions, {
+        ...babelBaseOptions,
+        presets: [[solid, solidOptions]]
+      });
+      const result = await babel__namespace.transformAsync(code, babelOptions);
+      if (!result) {
+        return undefined;
+      }
+      maps.push(result.map);
+      const finalCode = injectSsrModuleId(await resolveLazyModuleUrls(this, result.code || '', id), moduleId, !!isSsr);
+      return {
+        code: finalCode,
+        map: combineSourcemaps(maps)
+      };
+    }
+  };
+
+  // The directive transform must run before the JSX transform (it operates
+  // on raw directives, and client-mode module-level extraction must happen
+  // before templates are generated), so its sub-plugins go first. The
+  // boundary markers (`server-only` / `client-only`) are always on.
+  const plugins = options.serverFunctions ? [boundaryModules(), ...serverFunctions(options.serverFunctions === true ? {} : options.serverFunctions, {
+    devMiddleware: true,
+    externalDevServer,
+    // 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 ? {
+      ssrHandler: SSR_HANDLER_ID
+    } : {})
+  }), mainPlugin] : [boundaryModules(), mainPlugin];
+
+  // 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) {
+    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, {
+      serverFunctions: !!options.serverFunctions,
+      serverComponents,
+      ssr: !!options.ssr
+    }));
+  }
+
+  // Builder-mode (environments API) client-before-server build ordering.
+  // Server builds read the client manifest — `virtual:solid-manifest` bakes
+  // dist/client/.vite/manifest.json in, and the persisted server-function
+  // manifest merges the client build's discoveries — so the client
+  // environment must build first. Start mode's own orchestration already
+  // orders it that way (environment definition order), but a composed setup
+  // whose orchestrator builds server environments first (e.g.
+  // @cloudflare/vite-plugin's buildApp, which builds workers before client)
+  // 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):
+  // - 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
+  //   `pre`: pre-order buildApp hooks are where hosts do destructive
+  //   preparation — nitro v3's `nitro:prepare` rm -rf's the whole output
+  //   directory from a pre-order hook, so a pre-order client build sorted
+  //   before it built into a directory that was then wiped (client assets
+  //   and manifest gone, the manifest-less fallback baked into the server
+  //   bundle, prod 500s). Normal order still runs before every known
+  //   server-first orchestrator: a config-level `builder.buildApp`
+  //   (@cloudflare/vite-plugin's workers-before-client orchestrator) is
+  //   invoked by Vite only after all pre- and normal-order plugin hooks
+  //   (just before the first post-order hook), and hook-based orchestrators
+  //   (nitro's `nitro:main`, cloudflare's own companion hook) declare
+  //   post order. Orchestrators running after skip the client via `isBuilt`
+  //   (or at worst rebuild it, which is wasteful but correct — the manifest
+  //   exists either way when the server environments build).
+  // - Building anything from a hook suppresses Vite's own
+  //   build-all-environments fallback (it only runs when *no* environment
+  //   is built), so a setup with no real orchestrator — e.g. start mode's
+  //   plain `builder: {}` — would end up with only the client built. The
+  //   post-order hook reinstates exactly that fallback: when nothing but
+  //   our own client build has happened and no other plugin stakes a claim
+  //   on the app build, build the remaining environments in definition
+  //   order, precisely what Vite would have done. Another plugin declaring
+  //   a non-pre `buildApp` hook counts as such a claim even when it hasn't
+  //   built anything yet (its post-order hook may sort after ours):
+  //   building on its behalf would break staged orchestration (nitro
+  //   prerenders and copies public assets before its final server bundle)
+  //   and can error outright on environments the orchestrator knows to
+  //   skip (e.g. ones with no rollup input). Pre-order hooks don't count —
+  //   by convention they prepare (clean output dirs) rather than build.
+  if (options.ssr) {
+    let clientBuiltFirst = false;
+    plugins.push({
+      name: 'solid:client-build-first',
+      apply: 'build',
+      async buildApp(builder) {
+        const client = builder.environments.client;
+        if (!client || client.isBuilt) return;
+        const clientBuild = client.config.build;
+        const hasInput = !!clientBuild.rollupOptions?.input || fs.existsSync(path.resolve(builder.config.root, 'index.html'));
+        if (!clientBuild.manifest || !hasInput) return;
+        await builder.build(client);
+        clientBuiltFirst = true;
+      }
+    }, {
+      name: 'solid:client-build-first/complete',
+      apply: 'build',
+      buildApp: {
+        order: 'post',
+        async handler(builder) {
+          if (!clientBuiltFirst) return;
+          // Another plugin declares its own (non-pre) buildApp hook — the
+          // app build is spoken for, even if that hook sorts after this
+          // one and hasn't run yet.
+          const otherOrchestrator = builder.config.plugins.some(p => {
+            if (!p.buildApp || p.name.startsWith('solid:client-build-first')) return false;
+            return typeof p.buildApp !== 'object' || p.buildApp.order !== 'pre';
+          });
+          if (otherOrchestrator) return;
+          const environments = Object.values(builder.environments);
+          // A config-level orchestrator built something of its own — the
+          // app build is spoken for, don't build environments it may have
+          // skipped intentionally.
+          if (environments.some(env => env.isBuilt && env.name !== 'client')) return;
+          for (const environment of environments) {
+            if (!environment.isBuilt) await builder.build(environment);
+          }
+        }
+      }
+    });
+  }
+  return plugins;
+}
+
+exports.default = solidPlugin;
+exports.devStylePatch = devStylePatch;
+exports.serverFunctions = serverFunctions;
+//# sourceMappingURL=index.cjs.map