@solidjs/vite-plugin 3.0.0-next.34 → 3.0.0-next.36

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';
 
@@ -653,6 +653,16 @@ function solidDiagnostics() {
       }];
     },
     configureServer(server) {
+      // Announce the surface in the startup block. This is a discovery
+      // channel: agents watching dev-server output learn the endpoint and
+      // the skill documents without any project-level pointer (AGENTS.md).
+      const originalPrintUrls = server.printUrls.bind(server);
+      server.printUrls = () => {
+        originalPrintUrls();
+        const local = server.resolvedUrls?.local[0];
+        const endpoint = local ? new URL(DIAGNOSTICS_ENDPOINT, local).href : DIAGNOSTICS_ENDPOINT;
+        server.config.logger.info(`  ➜  Solid diagnostics: ${endpoint} ` + `(GET status; POST {"method":"begin"|"end"|"whyDidRun"|"costs"})\n` + `  ➜  Agent skills: node_modules/${DIAGNOSTICS_PACKAGE}/skills/agent-loops/SKILL.md, ` + `node_modules/solid-js/skills/reactivity-diagnostics/SKILL.md`);
+      };
       const pending = new Map();
       let nextId = 1;
       server.ws.on(RESPONSE_EVENT, data => {
@@ -1209,24 +1219,47 @@ 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.
+        const underMount = (pathname, mount) => pathname === mount || pathname.startsWith(mount + '/');
         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) {
+          if (!underMount(url.pathname, resolvedEndpoint) && !underMount(url.pathname, endpoint)) {
             return next();
           }
+          const basePrefixed = underMount(url.pathname, resolvedEndpoint);
           // 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 || '/');
+          const dispatchUrl = basePrefixed ? 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');
+            // The id lives in the path segment after the mount.
+            const mount = basePrefixed ? resolvedEndpoint : endpoint;
+            const segment = url.pathname.slice(mount.length + 1);
+            let functionId = null;
+            if (segment && !segment.includes('/')) {
+              try {
+                functionId = decodeURIComponent(segment);
+              } catch {
+                // 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));
@@ -1864,7 +1897,11 @@ function startServe(options, internal = {}) {
     // 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) {`,
+      lines.push(
+      // A call's address is `<endpoint>/<id>` (solidjs/solid#3076); 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 + '/')) {`,
       // 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
@@ -3460,6 +3497,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) {