fix: reclassify lazy facades without importers

.changeset/lazy-entry-eliminated-importers.md

@@ -0,0 +1,5 @@
+---
+'vite-plugin-solid': patch
+---
+
+Reclassify emitted lazy facade chunks even when their importers are eliminated from the final bundle. Emitted chunk references are now retained so lazy facades can be identified without relying on a surviving `dynamicImports` edge.

examples/vite-8/src/App.tsx

@@ -1,7 +1,6 @@
 import { onSettled } from "solid-js";
 import { CounterProvider, useCounter } from "./CounterContext";
-
-const title = 'Counter';
+import { title } from './UnusedLazyImporter';
 
 function Count() {
   const counter = useCounter();

examples/vite-8/src/UnusedLazy.tsx

@@ -0,0 +1,3 @@
+export default function UnusedLazy() {
+  return <p>This lazy component should be removed from the application.</p>;
+}

examples/vite-8/src/UnusedLazyImporter.ts

@@ -0,0 +1,9 @@
+import { lazy } from 'solid-js';
+
+export const title = 'Counter';
+
+export class UnusedLazyImporter {
+  mount() {
+    return lazy(() => import('./UnusedLazy'));
+  }
+}

examples/vite-8/vite.config.ts

@@ -3,6 +3,33 @@ import solidPlugin from 'vite-plugin-solid';
 
 export default defineConfig({
   plugins: [
-    solidPlugin({ compiler: 'native' }),
+    {
+      name: 'simulate-eliminated-lazy-importer',
+      enforce: 'pre',
+      generateBundle(_options, bundle) {
+        for (const output of Object.values(bundle)) {
+          if (output.type === 'chunk') {
+            output.dynamicImports = [];
+          }
+        }
+      },
+    },
+    solidPlugin({ compiler: 'native', ssr: true }),
+    {
+      name: 'assert-single-entry',
+      enforce: 'post',
+      generateBundle(_options, bundle) {
+        const entries = Object.values(bundle).filter(
+          (output) => output.type === 'chunk' && output.isEntry,
+        );
+        if (entries.length !== 1) {
+          throw new Error(
+            `Expected one entry chunk, received: ${entries
+              .map((entry) => entry.fileName)
+              .join(', ')}`,
+          );
+        }
+      },
+    },
   ],
-});
+});

src/index.ts

@@ -310,6 +310,10 @@ export default function solidPlugin(options: Partial<Options> = {}): Plugin[] {
   // 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<string>();
+  // 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: string[] = [];
 
   // Whether the current hook invocation belongs to a client (browser) build.
   // Builder-mode builds (e.g. SolidStart's nitro plugin) run the client and
@@ -557,7 +561,9 @@ export default function solidPlugin(options: Partial<Options> = {}): Plugin[] {
         if (!/\.[mc]?[tj]sx?$/i.test(cleanId)) continue;
         if (emittedLazyChunks.has(depId)) continue;
         emittedLazyChunks.add(depId);
-        this.emitFile({ type: 'chunk', id: depId, preserveSignature: 'exports-only' });
+        emittedLazyChunkRefs.push(
+          this.emitFile({ type: 'chunk', id: depId, preserveSignature: 'exports-only' }),
+        );
       }
     },
 
@@ -623,7 +629,22 @@ export default function solidPlugin(options: Partial<Options> = {}): Plugin[] {
       // 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) normalizeEmittedLazyEntries(bundle);
+      if (options.ssr) {
+        for (const ref of emittedLazyChunkRefs) {
+          let fileName: string;
+          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);
+      }
       substituteClientManifest(bundle, buildClientAssetMap(bundle, projectRoot, base));
     },