@solidjs/vite-plugin 3.0.0-next.40 → 3.0.0-next.41

package/dist/esm/index.mjs

@@ -2095,9 +2095,13 @@ function startServe(options, internal = {}) {
     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;`, `}`);
+      // The plugin's manifest module names the client entry it injected
+      // into the build (`_entry`): every configured input is a genuine
+      // `isEntry` record (a filesystem router's `buildInputs` lists every
+      // route module), so scanning for the first flagged record would pick
+      // whichever sorts first (#353). The scan stays as the fallback for
+      // hand-rolled manifests without the stamp.
+      `  const stamped = manifest._entry && manifest[manifest._entry];`, `  if (stamped && stamped.file) {`, `    return (clientEntryUrl = joinAssetPath(manifest._base, stamped.file));`, `  }`, `  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)};`);
@@ -2321,6 +2325,7 @@ function startServe(options, internal = {}) {
       }
       const build = env.command === 'build';
       const clientInput = entries.generated ? ENTRY_CLIENT_ID : path.resolve(root, entries.entryClient);
+      internal.onClientEntryResolved?.(clientInput);
       // 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
@@ -3426,6 +3431,23 @@ function getExtension(filename) {
   const index = filename.lastIndexOf('.');
   return index < 0 ? '' : filename.substring(index).replace(/\?.+$/, '');
 }
+// The packages whose dev/production server builds are selected by the
+// `development` export condition. A dependency on either means the package
+// consumes the runtime and must resolve it through Vite in dev.
+const SOLID_RUNTIME_PKGS = ['solid-js', '@solidjs/web'];
+
+// Tooling that declares solid-js as a peer but never runs inside the SSR
+// module runner. Kept out of the crawl entirely: classifying them as
+// semi-framework would also crawl THEIR dependencies, which vitefu deep-
+// includes in the client optimizer (`@solidjs/vite-plugin > @babel/core`
+// pre-bundled for the browser — ~2.6 MB of dead weight per cold start).
+// Mirrors vite-plugin-svelte's isCommonDepWithoutSvelteField list.
+const NON_RUNTIME_SOLID_PKGS = ['@solidjs/vite-plugin', 'vite', 'vitest', 'eslint-plugin-solid'];
+const NON_RUNTIME_SOLID_PREFIXES = ['vite-plugin-', 'eslint-plugin-', 'prettier-plugin-', '@types/'];
+function isNonRuntimeSolidPkg(name) {
+  const bare = name.slice(name.lastIndexOf('/') + 1);
+  return NON_RUNTIME_SOLID_PKGS.includes(name) || NON_RUNTIME_SOLID_PREFIXES.some(p => (p.startsWith('@') ? name : bare).startsWith(p));
+}
 function containsSolidField(fields) {
   const keys = Object.keys(fields);
   for (let i = 0; i < keys.length; i++) {
@@ -3652,6 +3674,66 @@ function normalizeEmittedLazyEntries(manifest, {
     }
   }
 }
+
+/**
+ * The manifest key of THE client entry — the chunk whose `<script
+ * type="module">` boots the page and whose static import graph carries the
+ * global CSS. `isEntry` cannot answer this: every configured build input is
+ * a genuine entry (#347 keeps them flagged), and plugins routinely add more
+ * inputs than the application entry (filesystem-routing's `buildInputs`
+ * lists every route module, and route keys sort ahead of the plugin's own
+ * `virtual:` entry). So the identity comes from configuration instead: the
+ * entry start mode injected itself, or — outside start mode — the single
+ * configured input when there is exactly one (including Vite's default
+ * `index.html`). Several inputs and no start entry: no answer (null), and
+ * consumers keep their first-`isEntry` scan.
+ *
+ * Matched by key or `src`, the same two spellings `isConfiguredEntry` uses.
+ */
+function resolveClientEntryKey(manifest, startClientEntryId, clientBuild, root) {
+  let entryId = startClientEntryId;
+  if (!entryId) {
+    const input = configuredBuildInput(clientBuild);
+    const raw = input == null ? ['index.html'] : typeof input === 'string' ? [input] : Array.isArray(input) ? input : Object.values(input);
+    if (raw.length !== 1 || typeof raw[0] !== 'string') return null;
+    entryId = raw[0];
+  }
+  const {
+    manifestKeys
+  } = resolveConfiguredEntries(entryId, root);
+  for (const key in manifest) {
+    const record = manifest[key];
+    if (!record || typeof record !== 'object' || !record.file) continue;
+    if (manifestKeys.has(key) || typeof record.src === 'string' && manifestKeys.has(record.src)) {
+      return key;
+    }
+  }
+  return null;
+}
+
+/**
+ * Serializes the plugin's manifest module with the client entry made
+ * explicit: `_entry` names its key (the generated handler reads it before
+ * falling back to scanning for `isEntry`), and its record is moved to the
+ * front. The ordering matters for consumers that still identify the entry
+ * by the first `isEntry` record — `@solidjs/web`'s `registerEntryAssets`,
+ * which links the entry graph's stylesheets and modulepreloads into
+ * `<head>`, and hand-rolled server entries — so they and `_entry` agree on
+ * the same chunk. Other configured inputs keep `isEntry`; they are genuine
+ * entries, just not the one the document boots.
+ */
+function stampClientEntry(manifest, entryKey, base) {
+  const ordered = {};
+  if (entryKey && manifest[entryKey]) {
+    ordered[entryKey] = manifest[entryKey];
+  }
+  for (const key in manifest) {
+    if (key !== entryKey) ordered[key] = manifest[key];
+  }
+  ordered._base = base;
+  if (entryKey && manifest[entryKey]) ordered._entry = entryKey;
+  return ordered;
+}
 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 })`.');
@@ -3715,6 +3797,11 @@ function solidPlugin(options = {}) {
   // two-invocation build (`vite build --ssr`) still knows the client's
   // entries when it bakes the client manifest in.
   let clientBuildConfig = null;
+  // The client entry start mode injects into the client build's input
+  // (reported by startServe): the one input that IS the application entry,
+  // as opposed to further inputs other plugins add (e.g. filesystem-routing's
+  // `buildInputs`, which lists every route module). Null outside start mode.
+  let startClientEntryId = null;
   let solidPkgsConfig;
   const tsrxCss = new Map();
 
@@ -3876,6 +3963,28 @@ function solidPlugin(options = {}) {
         isBuild: command === 'build',
         isFrameworkPkgByJson(pkgJson) {
           return containsSolidField(pkgJson.exports || {});
+        },
+        // `false` = neither framework nor semi-framework, and don't crawl
+        // its deps; `undefined` = unknown, fall through to the json checks.
+        isFrameworkPkgByName(name) {
+          return isNonRuntimeSolidPkg(name) ? false : undefined;
+        },
+        // Under `vite dev` the runtime must not be split in two. Inlined
+        // modules resolve `solid-js` through Vite with `development` (its dev
+        // server build); an externalized package's own imports are resolved by
+        // Node, which has no `development` condition, so it loads the
+        // production build instead. Both then run, each with its own
+        // `sharedConfig` — the manifest `renderToStream` sets lands on one and
+        // `lazy()` reads the other. `resolve.externalConditions` below only
+        // fixes the external's own entry, not what it imports, so every
+        // package that consumes the runtime has to go through Vite as well.
+        // Semi-framework is the right class: `ssr.noExternal` without
+        // `optimizeDeps.exclude`, since these hold no raw Solid components.
+        isSemiFrameworkPkgByJson(pkgJson) {
+          // Same gate as the core inlining in configEnvironment: dev serve
+          // only, never vitest (it manages inlining via test.server.deps).
+          if (!replaceDev || isTestMode) return false;
+          return SOLID_RUNTIME_PKGS.some(name => pkgJson.dependencies?.[name] || pkgJson.peerDependencies?.[name]);
         }
       });
 
@@ -4049,8 +4158,16 @@ function solidPlugin(options = {}) {
       // 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];
+          const noExternal = [...(Array.isArray(config.resolve.noExternal) ? config.resolve.noExternal : []), ...solidPkgsConfig.ssr.noExternal];
+          config.resolve.noExternal = noExternal;
+          // vitefu externalizes the non-framework deps of every framework
+          // package in dev, and Vite gives `external` precedence over
+          // `noExternal`. A framework package that lists solid-js or
+          // @solidjs/web under `dependencies` (not peer — e.g.
+          // @tanstack/solid-router 2.0.0-rc.7 → @solidjs/web) would therefore
+          // re-externalize a core inlined above and split the runtime again.
+          // Nothing inlined may appear in `external`.
+          config.resolve.external = [...(Array.isArray(config.resolve.external) ? config.resolve.external : []), ...solidPkgsConfig.ssr.external.filter(dep => !noExternal.includes(dep))];
         }
       }
     },
@@ -4210,8 +4327,7 @@ function solidPlugin(options = {}) {
             warn: message => this.warn(message),
             repairDynamicEntries: true
           });
-          manifest._base = base;
-          return `export default ${JSON.stringify(manifest)};`;
+          return `export default ${JSON.stringify(stampClientEntry(manifest, resolveClientEntryKey(manifest, startClientEntryId, clientBuildConfig, projectRoot), base))};`;
         }
         // SSR build before the client build produced a manifest: bake in the
         // dev-shaped fallback (registry miss degrades to js-only resolution).
@@ -4523,6 +4639,9 @@ function solidPlugin(options = {}) {
       onDocumentResolved(documentPath) {
         // Normalize to forward slashes to match Vite's transform ids.
         documentModuleId = documentPath ? documentPath.split(path.sep).join('/') : null;
+      },
+      onClientEntryResolved(entryId) {
+        startClientEntryId = entryId;
       }
     }));
   }