@solidjs/vite-plugin 3.0.0-next.35 → 3.0.0-next.37

package/dist/esm/index.mjs

@@ -6,7 +6,7 @@ import { mergeAndConcat } from 'merge-anything';
 import { createRequire } from 'module';
 import path from 'path';
 import { Readable } from 'node:stream';
-import { createFilter, normalizePath, loadEnv, runnerImport, defaultClientConditions, defaultServerConditions } from 'vite';
+import { createFilter, normalizePath, loadEnv, runnerImport, defaultClientConditions, defaultServerConditions, defaultExternalConditions } from 'vite';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { crawlFrameworkPkgs } from 'vitefu';
 
@@ -63,7 +63,16 @@ function webRequestFromNode(req, urlPath, res) {
     signal = controller.signal;
   }
   const method = req.method || 'GET';
-  const body = method === 'GET' || method === 'HEAD' ? undefined : Readable.toWeb(req);
+  // Only attach a body when the request actually carries one. A web Request
+  // built by the browser for a bodyless POST has `body === null`, and the
+  // runtime keys off that (a present body that decodes to nothing is a 400
+  // since @solidjs/web 2.0.0-rc.5) — so an unconditionally attached (empty)
+  // stream misparses bodyless calls. HTTP/1 signals a body via
+  // Content-Length/Transfer-Encoding (RFC 9112 §6); the h2 compat API sets
+  // `stream.endAfterHeaders` when END_STREAM rode the headers frame.
+  const h2Stream = req.stream;
+  const hasBody = method !== 'GET' && method !== 'HEAD' && (h2Stream ? !h2Stream.endAfterHeaders : req.headers['transfer-encoding'] !== undefined || req.headers['content-length'] !== undefined && req.headers['content-length'] !== '0');
+  const body = hasBody ? Readable.toWeb(req) : undefined;
   return new Request(url, {
     method,
     headers,
@@ -1167,9 +1176,11 @@ function serverFunctions(options = {}, internal = {}) {
     `export function handleServerFunctionRequest(request, options) {`, `  const { event: eventInit, ...rest } = options || {};`, `  return handle(request, {`, `    provideEvent: provideRequestEvent,`, `    ...(eventInit ? { createEvent: (req) => ({ request: req, locals: {}, ...eventInit }) } : {}),`, `    ...rest,`, `  });`, `}`].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.
+  // Function IDs are `<name>-<xxHash32(root-relative path)>[-<ordinal>]`
+  // (identity-keyed, solidjs/solid#3109). The name is a JS identifier and
+  // never contains `-`, so the hash is always the second segment and 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) {
@@ -1181,7 +1192,7 @@ function serverFunctions(options = {}, internal = {}) {
       }
       hashIndexSize = manifest.server.size;
     }
-    return hashIndex.get(functionId.split('-', 1)[0]);
+    return hashIndex.get(functionId.split('-')[1]);
   }
   function moduleDevUrl(entry) {
     const relative = path.relative(root, entry).split(path.sep).join('/');
@@ -1219,10 +1230,11 @@ function serverFunctions(options = {}, internal = {}) {
         if (internal.externalDevServer || !isRunnableEnvironment(ssrEnvironment)) {
           return;
         }
-        // A call's address is `<endpoint>/<id>` (solidjs/solid#3076) — the
-        // mount plus exactly one path segment. Bare-mount requests still
-        // reach the runtime handler (it answers 404), so misdirected posts
-        // fail through the endpoint rather than falling through to SSR.
+        // A call's address is `<endpoint>/<id>` — plain HTTP — or
+        // `<endpoint>/data/<id>` — the scripted transport's own path
+        // (solidjs/solid#3076, #3094). Bare-mount requests still reach the
+        // runtime handler (it answers 404), so misdirected posts fail
+        // through the endpoint rather than falling through to SSR.
         const underMount = (pathname, mount) => pathname === mount || pathname.startsWith(mount + '/');
         server.middlewares.use((req, res, next) => {
           const url = new URL(req.url || '/', 'http://localhost');
@@ -1241,9 +1253,15 @@ function serverFunctions(options = {}, internal = {}) {
             // 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.
-            // The id lives in the path segment after the mount.
+            // The id lives in the path segment after the mount — behind a
+            // literal `data` segment on the scripted transport's address
+            // (solidjs/solid#3094). Segment count keeps the two apart: an id
+            // occupies exactly one segment, so `data/<id>` is only ever a
+            // data address, and a function id spelled `data` still parses at
+            // the bare one.
             const mount = basePrefixed ? resolvedEndpoint : endpoint;
-            const segment = url.pathname.slice(mount.length + 1);
+            let segment = url.pathname.slice(mount.length + 1);
+            if (segment.startsWith('data/')) segment = segment.slice(5);
             let functionId = null;
             if (segment && !segment.includes('/')) {
               try {
@@ -1252,14 +1270,6 @@ function serverFunctions(options = {}, internal = {}) {
                 // not an address; the runtime handler answers the 404
               }
             }
-            if (!functionId) {
-              // TRANSITIONAL (remove before 3.0 stable): the retired header
-              // and `?id=` addressing, kept only for the RC window where this
-              // plugin meets a @solidjs/web older than the path-addressing
-              // change (solidjs/solid#3076).
-              const headerId = req.headers['x-server-function-id'];
-              functionId = (typeof headerId === 'string' ? headerId.split('#')[0] : undefined) || url.searchParams.get('id');
-            }
             if (functionId) {
               const entry = moduleForFunctionId(functionId);
               if (entry) await ssrEnvironment.runner.import(moduleDevUrl(entry));
@@ -1898,7 +1908,8 @@ function startServe(options, internal = {}) {
     lines.push(``, `async function dispatchRequest(request, event, options) {`);
     if (composeServerFunctions) {
       lines.push(
-      // A call's address is `<endpoint>/<id>` (solidjs/solid#3076); the
+      // A call's address is `<endpoint>/<id>` or `<endpoint>/data/<id>`
+      // (solidjs/solid#3076, #3094); the prefix gate covers both, and the
       // bare mount still routes so a misaddressed request 404s through the
       // runtime handler instead of rendering a page at it.
       `  const requestPath = new URL(request.url).pathname;`, `  if (requestPath === endpoint || requestPath.startsWith(endpoint + '/')) {`,
@@ -1971,6 +1982,7 @@ function startServe(options, internal = {}) {
       devtoolsResolutions = {};
       devtoolsIds = {};
       entries = resolveEntries(root, options, clientMode);
+      internal.onDocumentResolved?.(entries.document);
       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).
@@ -2964,6 +2976,11 @@ const LAZY_PLACEHOLDER_PREFIX = '__SOLID_LAZY_MODULE__:';
  * solid-refresh#85 — is no longer used at all).
  */
 const REFRESH_RUNTIME_SOURCE = 'solid-js/refresh';
+
+// Appended to the document shell's client compile instead of a refresh
+// boundary (see documentModuleId in solidPlugin): self-accept, then
+// invalidate — Vite's spelling for "this module cannot hot-update, reload".
+const DOCUMENT_HMR_DECLINE = '\nif (import.meta.hot) {\n  import.meta.hot.accept(() => import.meta.hot.invalidate());\n}\n';
 const DEFAULT_STYLE_EXCLUDE = /node_modules/;
 const VIRTUAL_MANIFEST_ID = 'virtual:solid-manifest';
 const RESOLVED_VIRTUAL_MANIFEST_ID = '\0' + VIRTUAL_MANIFEST_ID;
@@ -3255,6 +3272,15 @@ function solidPlugin(options = {}) {
   const externalDevServer = !!options.ssr && !!startOptions?.external;
   let needHmr = false;
   let replaceDev = false;
+  // Resolved absolute path of the start-mode document shell (normalized to
+  // forward slashes, matching Vite ids), reported back by the start plugin's
+  // config hook. The document is the one module whose client compile must
+  // decline HMR instead of taking a refresh boundary: it hydrates the whole
+  // `document`, and no component swap can re-claim `document.documentElement`
+  // — an accepted update would be absorbed with nothing visibly changing
+  // (solidjs/solid#3151). Declining makes a save invalidate the module, so
+  // Vite falls back to a full page reload: the honest cost.
+  let documentModuleId = null;
   // 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;
@@ -3497,6 +3523,20 @@ function solidPlugin(options = {}) {
       // real server build resolves (isServer true).
       ...(isTestMode && !serverTestPosture && !opts.isSsrTargetWebworker ? ['browser'] : []), ...config.resolve.conditions];
 
+      // `resolve.conditions` above only governs modules Vite inlines.
+      // Externalized server deps are resolved by `fetchModule` with
+      // `resolve.externalConditions` (default `['node', 'module-sync']`) and
+      // handed to the module runner as concrete file paths — without
+      // `development` there, packages that select their dev build through
+      // the `development` export condition (@solidjs/web's server-functions
+      // runtime among them) run their PRODUCTION copy under `vite dev`:
+      // server errors reach the client sanitized to "Internal Server Error"
+      // instead of carrying the real message, dev-only diagnostics vanish.
+      // So the dev flag has to reach both lists.
+      if (replaceDev && config.consumer !== 'client' && name !== 'client') {
+        config.resolve.externalConditions = ['development', ...(config.resolve.externalConditions ?? defaultExternalConditions)];
+      }
+
       // 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) {
@@ -3555,7 +3595,8 @@ function solidPlugin(options = {}) {
       };
     },
     hotUpdate({
-      modules
+      modules,
+      file
     }) {
       // solid-refresh only injects HMR boundaries into client modules, so
       // non-client environments have no accept handlers. Without this, Vite
@@ -3575,6 +3616,19 @@ function solidPlugin(options = {}) {
           this.environment.hot.send({
             type: 'full-reload'
           });
+          // Server-only modules are the exception to the suppression: a file
+          // with no modules in the client graph has no browser HMR path at
+          // all — nothing client-side accepts it, so staying silent leaves
+          // the browser rendering stale server output until a manual refresh
+          // (e.g. the document shell, which only the server ever imports;
+          // solidjs/solid#3151). Reload the page: the honest cost, and there
+          // is no client update to race with by construction.
+          const clientEnv = devServer?.environments.client;
+          if (clientEnv && !clientEnv.moduleGraph.getModulesByFile(file)?.size) {
+            clientEnv.hot.send({
+              type: 'full-reload'
+            });
+          }
         }
         return [];
       }
@@ -3678,7 +3732,12 @@ function solidPlugin(options = {}) {
       if (shouldBeProcessedWithTypescript) {
         plugins.push('typescript');
       }
-      const needRefresh = needHmr && !isSsr && !inNodeModules;
+
+      // See the documentModuleId declaration: the document shell declines HMR
+      // (no refresh boundary, explicit self-invalidation) so edits full-reload.
+      const isDocumentShell = documentModuleId !== null && id === documentModuleId;
+      const needRefresh = needHmr && !isSsr && !inNodeModules && !isDocumentShell;
+      const declineHmr = isDocumentShell && needHmr && !isSsr;
       const babelUserOptions = await getBabelUserOptions(options, source, id, !!isSsr);
 
       // The native compiler picks its parser dialect from the file
@@ -3750,7 +3809,7 @@ function solidPlugin(options = {}) {
         maps.push(result.map);
         const finalCode = injectSsrModuleId(await resolveLazyModuleUrls(this, result.code || '', id), moduleId, !!isSsr);
         return {
-          code: finalCode,
+          code: declineHmr ? finalCode + DOCUMENT_HMR_DECLINE : finalCode,
           map: combineSourcemaps(maps)
         };
       }
@@ -3771,7 +3830,7 @@ function solidPlugin(options = {}) {
       maps.push(result.map);
       const finalCode = injectSsrModuleId(await resolveLazyModuleUrls(this, result.code || '', id), moduleId, !!isSsr);
       return {
-        code: finalCode,
+        code: declineHmr ? finalCode + DOCUMENT_HMR_DECLINE : finalCode,
         map: combineSourcemaps(maps)
       };
     }
@@ -3805,7 +3864,11 @@ function solidPlugin(options = {}) {
       serverComponents,
       ssr: !!options.ssr,
       styleFilter: filterDevStyles,
-      diagnostics: !!options.diagnostics
+      diagnostics: !!options.diagnostics,
+      onDocumentResolved(documentPath) {
+        // Normalize to forward slashes to match Vite's transform ids.
+        documentModuleId = documentPath ? documentPath.split(path.sep).join('/') : null;
+      }
     }));
   }